summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authoralgonautshant <shant@algorand.com>2021-10-13 11:45:59 -0400
committeralgonautshant <shant@algorand.com>2021-10-13 11:45:59 -0400
commitf673a22bfb7bfae080b206bde21eaf349d20fb5d (patch)
tree5fa55ec339f9e8ccf6f3daeb83f51948fc8310c6
parenta95751907eb7ffd7a5b1c353590eef2d235b99dd (diff)
Squashed commit of the following:feature/state-proof
commit 45374907a555ff57bbc0fa2f66ae8642f38fe514 Merge: 9f274c57 83bcaaa8 Author: algoidan <idan@algorand.com> Date: Wed Oct 13 14:09:41 2021 +0300 Merge remote-tracking branch 'origin/master' into feature/dilithium-scheme-integration commit 9f274c570ec75288d967ddf5f33bba75448d1166 Author: algoidan <f> Date: Wed Oct 13 13:34:40 2021 +0300 fix txnsyc cert encoding bug commit 919bdd2f8c3dd7eaa60124af15fa509b49b60856 Merge: 8aff58df a5165444 Author: algoidan <idan@algorand.com> Date: Tue Oct 12 14:52:45 2021 +0300 Merge remote-tracking branch 'origin/master' into feature/dilithium-scheme-integration commit 8aff58dfea5604edfec4b79b78413cbcadc28a39 Merge: 04dd9169 0d5b66ee Author: algoidan <f> Date: Sun Oct 10 18:28:23 2021 +0300 merge with txsync commit 04dd9169bc000278ddc6c715e7fef86e1f508b57 Merge: 1ef5c6b2 926d7261 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Mon Oct 4 15:47:49 2021 +0300 Merge pull request #2991 from algoidan/feature/dilithium-scheme-integration fixing comments and add PartitionTest commit 926d7261ddab7299fed2a0adf09728db9d83355b Author: algoidan <f> Date: Mon Oct 4 14:08:22 2021 +0300 fix fmt problems. commit 338873f0a66e0968826f03fbd604a2fd5c737ed3 Author: algoidan <idan@algorand.com> Date: Mon Oct 4 13:47:57 2021 +0300 adding sync tests commit 6ef20ce1fabc889a769b353ab954c19a79cf2ef2 Author: algoidan <idan@algorand.com> Date: Mon Oct 4 12:23:07 2021 +0300 fixing comments and add PartitionTest commit 1ef5c6b2addb05b01eab675a52f33db0e63f57f9 Merge: a9124a9e cfb49e66 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Oct 3 16:09:54 2021 +0300 Merge pull request #2987 from algoidan/feature/dilithium-scheme-integration Feature/dilithium scheme integration commit cfb49e669b897381aae00aadb4721496f01a9a37 Author: algoidan <f> Date: Sun Oct 3 13:44:38 2021 +0300 go mod fix commit d70240486f888f377615a8f31c639a2ca594d4ea Merge: a9124a9e f17f73ef Author: algoidan <f> Date: Sun Oct 3 13:13:41 2021 +0300 merge with master commit a9124a9e8bedd6e41fd2bfe5b77aa5bd6fcce94f Merge: aa635dad 66c5f41c Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Wed Sep 29 17:05:57 2021 +0300 Merge pull request #2946 from algonathan/e2e-no-stateproof-tests E2E PR for new stateProof keys commit 66c5f41c0ee04e764b7023ce7960f7f513645b63 Author: algoidan <idan@algorand.com> Date: Wed Sep 29 14:22:17 2021 +0300 remove the long test. commit aa635daddf34997a6b88fc2abfa32609e2eabaf6 Merge: 1f92b43b bbf2cf23 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Wed Sep 29 14:51:29 2021 +0300 Merge pull request #2888 from algonathan/benchmark-addition added benchmark to participation. refactored fillDB benchmark too. commit bbf2cf23a64f02782e1d5c982f401f4cd125e934 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Sep 29 13:36:52 2021 +0300 fix for review commit a7b3208fda183d42e1f12b77d3eae783b292f199 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Sep 29 11:58:47 2021 +0300 removed test commit 54f9352689433993422e1c98d6a545936c6ce7b4 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Sep 29 11:37:04 2021 +0300 changed todo commit a2270abd8b55d25f10e947b013af9b2a38103f0b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Sep 29 11:29:41 2021 +0300 added partitionTest to each test commit cb1c6953782dbf8726033be658d5cc3cb959bb43 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sat Sep 25 14:43:47 2021 +0300 added a scenario that makes certain compact cert are being made after concensus upgrade commit 4d6785a34a0e516c846fde365defbf8999bfea9d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sat Sep 25 11:15:27 2021 +0300 added large participation key registration commit 1188d66da2688e041bd365169fcf55408f726d03 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Fri Sep 24 17:09:29 2021 +0300 changed comments commit eababac676738cbf268543fadb3f884819435856 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Fri Sep 24 16:53:17 2021 +0300 added test for participating after concensus upgrade commit 232dd53f5640f733328361d2d07cbe6c4fb6fbd5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Fri Sep 24 15:58:19 2021 +0300 refactored func signature to not pass fields of Fixture object commit 2398a7f21e6ebf3bae1ef4e7305333c3de79951c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Sep 23 17:54:13 2021 +0300 added a test that inspects old keys can be made up to the version upgrade, and that after ver upgrade new participation keys with stateproof keys can be made commit ca66c85e3842aa0bd71e9d4c7c82fbddc5c6c402 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Sep 23 15:46:19 2021 +0300 refactored the way testing for upgrade and sending txns work and added a test for v29 commit a647428bdf3e842cafcac10128b437fd2beeb655 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Sep 23 15:51:04 2021 +0300 concensus can keep on sending money after reaching version future from version V29 commit 3541bcae67f088d743c336ecc777fef4d109a4ee Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Tue Sep 14 18:15:30 2021 +0300 added benchmark to participation. refactored fillDB benchmark too. commit 1f92b43b67160a7876604fe828b9b71ae76d1f92 Merge: 0665fe16 265cb5c9 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Sep 12 14:42:42 2021 +0300 Merge pull request #2874 from algoidan/feature/dilithium-scheme-integration update dilithium scheme integration branch with master commit 265cb5c9b8222ac85444cc0afa664e6a03683455 Author: algoidan <f> Date: Sun Sep 12 13:33:41 2021 +0300 reduce the default number of rounds commit 7ac171b2e9ce231702b88e3baf52a4f825b03438 Merge: 0665fe16 b8b7281d Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Sep 12 10:31:59 2021 +0300 Merge pull request #9 from algoidan/master merge with master commit 0665fe16780e36dca0ac6eb9e1da497fef0cdd8f Merge: 177b067f 5c5cd067 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Sep 12 10:08:32 2021 +0300 Merge pull request #2867 from algoidan/use-stateproof-in-compact-certificate fix layer bug. commit 5c5cd067f8e7c27424ae96e04731073c032dbf35 Author: algoidan <f> Date: Fri Sep 10 21:18:21 2021 +0300 using copy instead of append commit 69c2d78b61e66840ce6cad5aae6218657e59eb2c Author: algoidan <f> Date: Fri Sep 10 12:26:07 2021 +0300 fix layer bug. commit 177b067fd4b4c0c7aae55b949fc1c495f8701045 Merge: ba8b5c45 58125ae8 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Thu Sep 9 15:12:26 2021 +0300 Merge pull request #2845 from algoidan/use-stateproof-in-compact-certificate Compact certificate code now uses the state proof. commit 58125ae89d0f282edf432e55cbf868955b1b758b Author: algoidan <f> Date: Thu Sep 9 12:25:07 2021 +0300 CR fix commit f861f041d8e695fd2f201b0b29a2d6829d433424 Author: algoidan <f> Date: Mon Sep 6 16:35:05 2021 +0300 the compact certificate code now uses the state proof. commit ba8b5c45296d60b7bd618a86d4846c87a41526fd Merge: 7f18e4b3 4c05db06 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Sep 5 19:38:50 2021 +0300 Merge pull request #2843 from algoidan/feature/dilithium-scheme-integration updateFeature/dilithium scheme integration with master changes commit 4c05db066ea3504d451ec98fd63f134c83e68c77 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Sep 5 17:15:13 2021 +0300 fix: codegen_verification commit 12d3da1f7dfcd6e5c6c6e2b2f4995728b03f0328 Merge: 7f18e4b3 f8169d29 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Sep 5 14:14:32 2021 +0300 Merge pull request #8 from algoidan/master update the dilithium commit 7f18e4b3366110452494c94246835470ba5cf146 Author: Jonathan Weiss <85506383+algonathan@users.noreply.github.com> Date: Sun Sep 5 11:58:46 2021 +0300 Compcert sumhash integration (#2816) * comp-cert to use genericDigest, and sumhash * fix: compactcertState had nil digest * fix: daemon v1/handlers to use compactCertVoters as a generic digest * using genericDigest instead of Digest in block's CompactCertState * added magic num to crypto/compactcert * changed ledger/voters to use the same hash in the tree build as expected in compactcert * fix: using the size of the compactcert hash output instead of crypto.Digest * fix: changing comments * defined hash factory for the compactcerts * fix: using hashsize in compactcert/worker_test * removed TODO comment * renamed SumHash into GenericHashObject * removed unused function * fix: using compacert.Hashsize in e2e test * put matrix of sumhash creation inside init of crypto/hashes in addition to that, i've updated it to the newest copy of the correct implemantation * fix: using library number size for sha512_256ssize * removing commitment type from crypto/compcert * removed: newhashFactory from compcert * move compcerts constants into a specific file * changing the verification interface * fix CR * revert merklekeysotre to use ed25519 scheme for now * contine the revert to ed25519 and sha512_256 * fixing the broken txn proof * exporting the helper struct that validates transcation proof * removed unused struct from unit-test in bookkeeping Co-authored-by: algoidan <f> commit 71dcb0f9a22bde38c2808615fccf2da1909dd06c Author: Jonathan Weiss <85506383+algonathan@users.noreply.github.com> Date: Wed Aug 25 21:02:38 2021 +0300 Subsetsum (#2786) * msgpack updated * using defer instead of goto * added a hash factory * wip: using hash factories inside merklearraytree * removed code dup * tree uses factory to use hash inside the tree * fix: msgpack * upWorkers now use hash from factory * adding merklearray digest and returning root as TreeDigest * WIP: using TreeDigest inside merklearray * minor support for proof structs * merklearray proof structs * refactor: verify broken into sub functions, fixed issue with empty proof struct * Verify expects merklearray.Digest instead of crypto.Digest inside verify function * adjusted merkle keystore to work with the new merklearraytree api * Adjusted crypto/compactcert to use merklearrayTree new API * ledger, data, compactcert comply with the new merklearray api * fix: daemon/algod/server handlers to work with the merklearray proof * WIP: adding subset hash into merklearray and merklekeystore * testing merklearraytree with another hash type * fix: shouldn't have remove dtag from struct * fix: unit test adjustment in e2e * added unit tests to crypto.hashfactory * fix: using crypto.HashSum in merklearray.tree * reusing hashing code in merklearray * exporting crypto/util.go's hashRep * fix comment in merklearray/array.go * fix: comment in merklearray signer * fix: using hashSum instead of manually calculating the hash * removed wrapper for waitgroup.done * removed merklearray/pair.Hash() * refactor: merklearray Verify function * refactored the layer building of merklearray * reseting hash before usage * using const as magic number for digest size in merklekeystore * fix: proof for nothing should include the correct hashFactory of the tree too * added unit test for merklearray prove structure * moved merklearray.Digest -> crypto.GenericDigest * pass sanity checks * removed digest interface, changed to work with genericDigest type * fix: bug in verifying merklearray * added unit test for empty merklearray tree * removed unneeded hash reset * fix: typo in file name: crypto/digest.go * fix: reorder struct * renamed the subsetsumhash const. fixed keystore size to the size of the subsetsumhash commit bd11c41c7b4722c8bac8cc4732c287225090f834 Author: algoidan <f> Date: Thu Aug 19 12:39:13 2021 +0300 fixing partitiontest in msgpack tests commit de5304678fda51129650b327866e208ae4185c55 Merge: c6560bf5 e7788529 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Wed Aug 18 16:18:35 2021 +0300 Merge pull request #2765 from algoidan/feature/dilithium-scheme-integration Feature/dilithium scheme integration commit e778852913b26f7e16f3788560c1f484cd06d085 Author: algoidan <f> Date: Wed Aug 18 14:34:35 2021 +0300 fixing msgp pack test commit 032684333ed570d0e131143e082e034991f1a766 Merge: c6560bf5 f774e7e8 Author: algoidan <f> Date: Wed Aug 18 12:54:30 2021 +0300 merge with master commit c6560bf5c57cdba0a7e517f2ca3a767b4c27bdad Merge: b327bac6 04a4a53e Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Wed Aug 11 18:50:29 2021 +0300 Merge pull request #2678 from algonathan/dil-sigs Dil sigs commit 04a4a53e2e332aeb5af71a53296d1db258593a0c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 17:10:04 2021 +0300 added test for dilithium hashable commit ca217d679cf630ec2573a0b83910a3709c637137 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 15:29:58 2021 +0300 upgraded go-mod version of the algorand/dilithium fork commit af30fe43668106262e4c0312276e5106dfd46b2d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 13:59:01 2021 +0300 increased interval commit 36a2d3ef245d71761efac280898ae890b5a4a1f3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 11:43:11 2021 +0300 moved cdilithium wrapper to a different fork commit 095631fce3e9ca3717a94f88134b274256979e26 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 08:23:17 2021 +0300 compiling withoung rnadomised sig flag commit c46bd8f7d949dd8474691c3ee1865d2f3ccefbf2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 08:22:29 2021 +0300 cannot have empty signature commit 8d2e9bf5b0d6f74de449c861bd6358e844a4f46a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 11 08:17:06 2021 +0300 changing the codec name of dilithium public key commit 6110c7244fa13955d5c65bea3796d81d7a31cdae Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 9 12:16:32 2021 +0300 added constant values commit 38c5f51dfb44f27a2da323a6122396582df2985f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 9 11:51:56 2021 +0300 changed functions used from api.h commit 4229124dd348bc0dd37c6d6d4a22162631b797b1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 9 10:21:01 2021 +0300 rearanging cdilithium directories, cdillithium to use dil3, and randomized signing commit 3b7ae947986b6f8478be136989a548c42d9398f8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 9 09:15:59 2021 +0300 fix: typos in dilithium.go comments commit 7db6a9d603b6f667ab6e4df81a32ebe28472f1fa Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 9 09:14:32 2021 +0300 added unit test to crypto/dilithium commit 234694aba05e9be215c98e3f305da14fbb0e5744 Merge: a953718c b327bac6 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 8 08:04:41 2021 +0300 merged from feature/dilithium-schem-integration commit b327bac6d93b353c60f47b6a0dd684168f2e39a6 Merge: 630acdb1 39be0c77 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 8 08:02:11 2021 +0300 merged from main branch commit 630acdb1c9ebe16681c8b994e1f18e94298d00c9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Aug 5 18:32:33 2021 +0300 merged from main branch commit a953718c295aae4b62614886fe9d2a4360b2ffda Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Aug 5 14:36:22 2021 +0300 check for arm64 integration tests commit 78e73a35e209ed9cb95e57f315c83cbc0ac6c8f3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Aug 5 11:25:32 2021 +0300 fix lint checks commit 15d537d034ee2fb32c2116e9040071d21376b6f6 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Aug 5 11:00:49 2021 +0300 renamed dilithium library commit 9721ab36efc26e13bd65780852c38185d1c7dd8e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Aug 5 10:12:52 2021 +0300 new participation key will use keydilution as compactcertround parameter when it is unspecified commit 0181b530b8c9935e6b2e9a74b17bbe95fdcee01e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 4 19:50:06 2021 +0300 fix: go fmt commit e338300c600012f2268b25cc8eceb3019c75e87f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 4 19:30:16 2021 +0300 WIP: dilithium cgo, -o3 flag. still needs some configurations commit 1f7518dbe073a5bebf1eaef8dc1c9f306c182ae7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 4 14:46:35 2021 +0300 participation key creation will use concensus params to determine the compactcertRounds commit 874cb97c935d30177d9b1f567ed9578902c027c1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 4 10:47:05 2021 +0300 placeholder key turned into dilithium key commit 29da4833b61cba3147ff4eafe689f18926e19d74 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Aug 4 09:33:44 2021 +0300 squashed changes from master commit f647d09f72b7bf32575038c46dabbc70fe99746c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 2 15:13:18 2021 +0300 dillithiumkey basic integration: added key to the crypto library, made certain it supports signer interface. integrated it into the merklekeystore fix sanity-checks commit 9997eef55d77f60af4b1cf983a514b92d7f299b0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 2 07:46:17 2021 +0300 fix:msggen commit 396037d003263839a8ad40eb5355a5caf85b8de3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Aug 2 07:15:47 2021 +0300 removing valid testing for signatureAlgos commit 407f46263e6063ebf4b6985a709035ae8f0201e8 Merge: fdc2ed2d 4239dbe8 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Aug 1 19:06:23 2021 +0300 Merge pull request #2620 from algonathan/merklekeys-partkey-integration merkle-part-key-integration commit 4239dbe87299e21dc3b0bbc60531bdb6304713c6 Merge: ac16412e fdc2ed2d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 17:29:35 2021 +0300 Merge branch 'feature/dilithium-scheme-integration' into merklekeys-partkey-integration commit ac16412e81eeb408b8a42ad87666b92a83606ae8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 17:19:02 2021 +0300 concluded TODO in participation/account is not needed anymore commit e6a78e3a913be13f78bba9293fac75c47b81c80e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 16:52:05 2021 +0300 Squashed Review commits, all messages are present below: removed unused field from signature fix: comment of HasValidRoot removed unused function fix: firstValid = 1 instead of firstvalid++ fix: removed uint test from wrong Test suite added tests for signer creation with round zero fix: removed unneeded unit-test fix: error in unit test with bad merkle proof inside signature added case to unit test of signer creation added test case to trim:wq commit 575b1708ded85a75b9069608f4f7571d38c258a8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 16:49:48 2021 +0300 fix: fmt commit fdc2ed2da5f0f86c466136a8ed3b5eea35043c29 Merge: a33bde62 8835bfdd Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 15:31:14 2021 +0300 Merge branch 'master' into feature/dilithium-scheme-integration commit d1554d316786590fb72d4685fb128d966a22d43f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 14:31:38 2021 +0300 added a way to dicern empty verifier from verifier that is tied to a signer commit 73da6496a1d5461d5bbeb9625946d52f4fe17f6c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 13:02:10 2021 +0300 added unit tests commit 0ebf6e40dba5e1489bda06e5d8fe0f1a4a61b25b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 12:45:33 2021 +0300 fix: bug in new signer - overflow in roundToIndex, fixed by explicit writing the formula commit 0c0b30eac60184705257e37a384a4ea303334fad Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 12:25:06 2021 +0300 fix: renamed functionality to get indices and rounds commit 7e5e37725c99b4df00fdb1d607862ea70c6ffc0e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 11:18:07 2021 +0300 fix: changed receiver name to match signer first initial commit 6cc73e29a590390f087a54fcce3154ed806deee2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 11:16:26 2021 +0300 removed unneeded structure (EphemeralKeys) and merged into signer commit c22ae9f43034dc3743661fbfbaaf155909a36c9b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 11:03:57 2021 +0300 renamed firstValid commit 82df1bd4b37f18952725816941d31db3891362af Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 11:02:32 2021 +0300 reverted one commit back commit 8003b4b278b528292354b96697fbe8e92adf3db8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 10:02:49 2021 +0300 fix: added Status to verifier commit 867f775653d43ffd46ff69af9130cbe8b1ea521d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:52:58 2021 +0300 fix: using round instead of indexToRound in verify func commit cb948372c4e967f749c1310c3b1cba7a8082f400 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:50:13 2021 +0300 explicit init for ArrayBase commit 4aa8766db99089ee3d0c0f97bfbf2c1cad69049c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:48:35 2021 +0300 removed unused code commit 2ada1a8d0582eefd4392c2bae9709cc873c147db Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:47:55 2021 +0300 renamed field divisor to interval in merklekeystore.New function commit d0f3014213e0d7e21adf32f8fd4f97dd86abeef4 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:45:40 2021 +0300 fix: removed unused function numkeys, changed names of params from the roundToindex and IndexToRound commit 2924e7fce27b78d2d6e5be9e9763b3dc454d8c22 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:44:08 2021 +0300 removed commented out code commit 1c2244ce308a1d8192742e02bde3ea8dc63b34f0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Aug 1 07:43:16 2021 +0300 changed codec name, and removed unused field from verifier commit 569718c4536ae885d39102a2f13f22cb62c4ee90 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 29 14:46:06 2021 +0300 trim is set to work with specific keys only commit 374b584efba0ae61c95c27bc77a4521f6d70b3d7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 29 11:47:54 2021 +0300 renaming merklekeystore bases commit cf28b369cd4e3a27c3896fccfc9763ade2d8e42a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 29 10:59:25 2021 +0300 renamed divisor into interval commit cbd5241520a98c8622463d45b7b08acb305da15d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 29 07:27:23 2021 +0300 WIP: fixing trim commit 6ae373cb025f8e24639d85ec8cdc6611b9086575 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 19:40:05 2021 +0300 added test for divisor >1 in deletion tests commit d1e330e619241b17bd8ee2bbe3e2524d555d2bea Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 19:24:55 2021 +0300 ensuring no verification for round zero commit f558a6b81e57be71d7fb13ef4f8bb38a9a50bcbd Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 19:21:34 2021 +0300 fix: forgot to copy merklekeystore.signer originRound commit bda45988f958b8a6bd38d9a69bc61353f394188f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 19:16:58 2021 +0300 fix code panic on 0 divisor commit 67024ffc71bdd1a5ef45f06fa3992dbda4635cbb Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 19:02:52 2021 +0300 fix: signature and verification align with key spaces commit 4336371f2330d876a869d98a25c84ede9456ee79 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 16:25:48 2021 +0300 fix: bug in libgoal/participation - did not check errors commit 5be3594377ccd5d3467e6844abe4b00f191fb808 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 16:25:22 2021 +0300 fix: merklekeystore signer will not return invalid verifier commit 501648dd8adccda1802e33fd69741299a1be0c3b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 13:49:13 2021 +0300 decided not to support zero key, because it doesn't make sense commit c05998892c77559f8b85f6ca11fcc3825a8b1fb1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 11:40:44 2021 +0300 fix: sanity checks commit bf94257474a686b08a99f68d058a5cf8f1ee60bd Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 11:25:48 2021 +0300 WIP: dividing key rounds in merklekeystore commit 2e8e44f7f3d5538b0f296cf1a783d3f81f9525f3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 09:54:16 2021 +0300 fix: removed bad comments commit 874881a7eb90b4d8fa65b9090e3a7f52b5c92191 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 07:59:26 2021 +0300 fix: removed errors from Trim commit dbd3b5977a58029b11151b6b5612eb735f1063a9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 07:22:03 2021 +0300 fix: comment in participation struct commit 3c44410d3fd0f7ecc37c95bd4e381cd7b8f33d12 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 07:20:07 2021 +0300 fix: import conventions commit 02722f6a7122990ab820cd4b54afdf78cc63b4d7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 28 07:18:17 2021 +0300 fix: using error.new instead of fmt.Errorf when possible commit ffadbb81a1fee12baa357fc5794ab456ab35408e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 18:45:45 2021 +0300 fix: bad comment over Trim function commit 8804d9a4bb420d25cbb6ee9b77a341b1374a62a2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 18:39:42 2021 +0300 fix: comparision of merklekeystore.Signer inside tests commit fca0f8df0238aae1c0c019bf81f03fcd26295f28 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 16:59:51 2021 +0300 removed test for valid blockproofPK - no such check for new type of key commit 0e426672c69fd12b97809e88d6f31178aaa91a42 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 16:53:37 2021 +0300 added comments in merkle key store to fields in EphemeralKeys,Signer commit 2a3fc455d3b4566f84a257f38fbbbc3b31286071 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 16:15:30 2021 +0300 added a trimming function to the merklekeystore. commit cc85c8460a4c900c509172f2234729d94a0bb218 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 25 12:22:17 2021 +0300 removed unneeded firstRound param from signer commit 1294ab9e344e4f3f11f03caa2aa7e8c5b3d5c422 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 17:37:35 2021 +0300 removed some spaces commit bd36afe97be4bb2d25def994015c4a763a99a69c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 12:30:49 2021 +0300 fix: comment for EphemralKeys in merklekeystore commit a33bde627200d28bfa551f41c9b61dbcc307def5 Merge: fa1a50ab 9bcee442 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 16:15:21 2021 +0300 Merge branch 'master' into feature/dilithium-scheme-integration commit fa1a50ab2d2145c52f05e16969ab03d316485520 Merge: 752ab75d 97453b2f Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Thu Jul 22 15:38:43 2021 +0300 Merge pull request #2579 from algonathan/merklekeystore Merklekeystore commit 97453b2f28533305a95899742c16a64eccb3a1a7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 14:43:31 2021 +0300 fix: bug in unit test made comparision between pointer and struct commit 343b2c3df2ba6e57278625cf04897fcad1238ca0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 12:30:49 2021 +0300 fix: comment for EphemralKeys in merklekeystore commit 3b4bd4a2dd35247578ce5af2d9fabbb918f7a55c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 10:23:05 2021 +0300 changed signature test in merklekeystore commit 440760b8f881db963b01dd627583e1a8421dc479 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 10:13:16 2021 +0300 fix: msgpack for merklekeystore.Verifier commit 59fdb5e198221f194c297ffee84b44d1c51e2f16 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 22 09:01:01 2021 +0300 changed name of ephemralpk commit e0c0d1b051742186aa126d1f3cb97dc266384c40 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 17:45:26 2021 +0300 removed unused variable commit 538b06b0c5897da2b1505282ab6f73a3f4bda88e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 17:08:50 2021 +0300 fix: import style convention commit e29330fc61032565dbede57d2e363899c3c0f1bb Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 17:02:16 2021 +0300 fix: lexicographic order commit 8db9ebccc87e6d58650ae9f23bebe0fda14ae893 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 16:55:07 2021 +0300 api change commit f9327e085dd0ce59d65b031bb3c8258f5ce4964b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 12:25:01 2021 +0300 fix: 'make sanity' commit 45863aaac582912ffe351e9082d5d429ab1438f3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 12:15:55 2021 +0300 extended unit tests commit f9ad9421bde21754bb3929d200d06429892c36ac Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 11:29:03 2021 +0300 added const to EphemeralPublicKey ToBeHashed commit 7142dcd0cf314d4ae6130a1e8a7279eb7a8d0e6e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 11:02:22 2021 +0300 WIP: adding round commitment to the merklekeystore keys commit 6d30b99974a749b6afbf843e5759c0c887ed9516 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 21 09:21:27 2021 +0300 changed hashing function name for ephemeral keys commit 9e87fb3bfbc9ee6fb1b59e745c5b1753e3c48cec Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 17:06:59 2021 +0300 changed the merklekeystore to not rely on basics package commit 56cc5443e9158e2424f6777907d2e372e5bde628 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 16:12:44 2021 +0300 fix: test should've changed to inspect edge cases of getKeyPosition commit 965285c68428b6a0fc60b3be61f73c96456df4b8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 16:11:12 2021 +0300 added test case that ensures a single key is created with firstround=lastround commit 60f69dad7335b3024f5c31534a38da41e4f5cbaf Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 16:09:49 2021 +0300 shortend codec name commit d1fd32c02714737b421425a655cc0f55d087e6ad Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 16:05:43 2021 +0300 fix: removed test from within a test commit 631d245a307969f205f391423ea38568d24e6124 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 14:43:17 2021 +0300 fix: pass make sanity commit ac942cbaf921d192ce239f4a8039604a5812c479 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 14:42:55 2021 +0300 fix:removed unneeded param from New commit 7249dff4d7153c1069cfc2f91101fe776e04643b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 13:33:28 2021 +0300 refactor: changed types inside new function. commit 3c734ecdc38d2a430d7dc6d4b8bec6a02367ba35 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 13:24:02 2021 +0300 fix: support creation of keys for all rounds commit 30dfd7e18c1c49747edc80c0daf26baeea44eb50 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 10:08:56 2021 +0300 msgpack support for merklekeystore commit 44fdb60a35a9c5f691f9f1ca9cead9d1b09477f8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:38:01 2021 +0300 fix: added a test case to ensure signer always contains at least one key commit 3562ad482876d464d766a1c0d963de7530764d12 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:32:52 2021 +0300 removed t.run() from tests commit ae182b7ec731487c880eb86e0a2c1573d414128e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:26:41 2021 +0300 merklekeystore.signer expects key type to be provided commit 4599f09d928707c5f20347aec05c663bb73338e5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:22:59 2021 +0300 removed unneeded comment commit fedd627cbac0ffa8cb6c2d833594aa07b490e27c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:21:37 2021 +0300 removed unneeded params from merklekeystore.Verifier commit 98f09211fd224242c9be1b13f1fbbb64f52fbe07 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:19:28 2021 +0300 added codec to merklekeystore.signer commit a3d883969cb8977f543a4e9ff6bc4bb92743acc8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 19 08:17:54 2021 +0300 renamed ephemral keys commit ed6736811009b4e41585c65c4236409207a86ff3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 18 14:08:51 2021 +0300 fix: unit test failed because of parallel flag commit 2308acc926dce5f5a9088cb33de5eea1ad16b3ff Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 18 13:24:19 2021 +0300 fix: code now aligns with sanity checks commit a15cb6af310e534ba1b4f070e8407666fe949f33 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 18 11:25:10 2021 +0300 creating merkle key store a package in crypto to support multiple key generation for rounds. the merkle key store outputs a signer and a verifier to be used. commit 25e832fa4612c95d6d34624c0dddcc359cda8f5e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 18 09:30:27 2021 +0300 verifyingKey conforms with Hashable interface commit 752ab75d041b13b88d38e82690f4d83ae9d4cea5 Merge: 7e70ca2b 689f9fa0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 15:19:45 2021 +0300 Merge branch 'feature/dilithium-scheme-integration' of github.com:algorand/go-algorand into feature/dilithium-scheme-integration commit 7e70ca2b8f1a92f37727e575ee37935eec798277 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 13:35:22 2021 +0300 fix: make lint commit 3cf4bbfa375b7cf1bfeb1ecd80d9e7a0c737d2d1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 11:46:49 2021 +0300 gen generates blockProofPK only once the key is enabled commit 2959e6bd423a354aa54e4cc74fb0404eaa8688bd Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 11:27:02 2021 +0300 corrected apply. added test for current ver and future ver commit 07a1f614626c4baeed3590c93fdd9ff4dfbc24e3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 10:57:58 2021 +0300 fix: reused comparision inside blockProofPKWellFormed commit e9dfbff421d1bdbb12b86eb485a09d2f352c9152 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 10:55:33 2021 +0300 repositioned the checks for blockproofPK commit 3d11029409877bd59c444f768e9df36e5ae9e17e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:33:54 2021 +0300 covered line in wellform check of the blockProofPK commit 739d23b767a361a24adf1f94a22717abf528f7d7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:27:27 2021 +0300 fix: go fmt commit 1a7b98ce026d13c5b8ac30aba64b3f92567d9845 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:25:03 2021 +0300 removed unused function commit 429e899f0cc68748db9f2f089ec418c48f9b9ec2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 18:28:59 2021 +0300 keyreg txn creation takes into account the current version commit d9756b621593088bf4827cfe7f0569deedd7cdaa Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 14:28:28 2021 +0300 fix: added to goal network genesis creation function the blockProofID too commit 130841a2373b019d1ac2590f306d90da430724a8 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 11:48:41 2021 +0300 fix: blockProof wellformed checks that offline keyreg is correct commit 3268e14ab64073df87128e209ed8d489da00cad1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 11:08:57 2021 +0300 added wellFormed checks for offline commit 1e07385cfc9f3ac21cf4df589798951b1abef0fc Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 18:47:53 2021 +0300 shorter codec names for blockProofPKs commit de1566c27f25e0839622fc62e02d332b638f5b2f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 18:43:25 2021 +0300 fix: didn't check offline requests on the blockProofPK commit ae7a18d0a6161fcdfbb54d7a6c088196b8b130f1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 11:19:14 2021 +0300 added test that inspects blockProofPK are stored in the account commit 82dbcba4302bea1dae7d3c8aceb517d3a19fb923 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 08:50:32 2021 +0300 fix: correct keyregTXNfields for different version types commit 1208690db89eb7e41e1ec226b512038ac9ed9fa5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 17:35:42 2021 +0300 fix: because WellFormed is run before keyreg - no need to check BlockProofPK inside Keyreg commit ce7f678adf4a738621560c6d3d329f407edb0ef5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 16:10:42 2021 +0300 fix: transaction wellformed now checks if blockProofPK is valid commit 02414eeb6da6a5ba76436d75a99b843fca07b1d7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 16:03:39 2021 +0300 added unit test to keyreg apply commit c6605aae4206835a8989d17eddae77f8befe59b6 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 15:03:50 2021 +0300 added basic support to wellformness of keyReg transaction commit 87204adb40c2bfed175d2fa014af7de0dc79529d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 13:12:05 2021 +0300 renamed blockProofPK commit 5d2951aa415bf3c2d71cf02503ca110f5162e300 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 14:13:42 2021 +0300 added to structs in data package compact cert keys commit db862c3335e6cda74a7d230f617e256a6b16976c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 12:55:32 2021 +0300 altered comments commit 81229a05487c4d992bc53073b56b2892ac4e945b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 12:46:50 2021 +0300 renamed partkeyInfo field commit 1b0bb9ccb40603639023a3727ec77b70e6ec4e1f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 08:00:46 2021 +0300 added liscenses to new files commit b6b682d94d3af17889853d3a8599338b6e6ac880 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 07:52:00 2021 +0300 changed name of compactCert key commit 164790a4d625a9aa4d14705529d8a9f20715627c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 19:41:32 2021 +0300 fix: changed comments commit b34bcceb84d0314b77f2f1a5e5d030e293b4585b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 13:29:02 2021 +0300 interface change commit b687250b87d9b7ad10e3e754b282641a7345e87b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 11:00:25 2021 +0300 refactor: cleaned if statement commit 0317dc3d0bbc00cac29b8f6faf316396a0ddc2ee Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 10:48:41 2021 +0300 fix: part.CompactCertSigner returned nil, made certain to inspect that commit a89dee56ea97baa4098e71c32fd019d7f4b6c1c2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 14:21:00 2021 +0300 added space in a tx.Exec query string commit 75869910844c2cea6df2d3865b8401c1c95aeede Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:52:52 2021 +0300 changed subTests into Tests commit 9bddd1006b9ca6c9a833a1726bc427841880ac3c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:44:42 2021 +0300 move variable to test commit edc8c706a3b6bc0b6f64a668f4390fc49d8c5989 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:40:49 2021 +0300 changed comment commit 5fb257e18fafc5991d94e34b2d6b2be2389d079a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:32:16 2021 +0300 fix: did not return error from function commit be42ad969c0fcb0a65cb588ea717b8e2226ddebd Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:17:18 2021 +0300 fix: bad design in getting verifyingKey commit 43033487aa702e6878e1d1e9939ba97f2e762db2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 17:10:06 2021 +0300 changed Verifier interface commit d8b71d0d6f6aaf6fd84f9d08cf2330cd97ae321a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 16:20:20 2021 +0300 added test to retrieve participation keys from an unupdated DB commit 3e5461ceb122ce4464c6a9bd5942f73b0454f26b Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 15:09:03 2021 +0300 lint fix commit f4e90cefd8218041f70fa29d5d4b260fcd7889d3 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 14:14:49 2021 +0300 added migration tests to participation package commit 936e59f24ef6f5eb12faf5089d9aa71262c7a99e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 11:49:35 2021 +0300 fix: bug in migrate, added a unit test to check migration commit fd626513cdbfa19bfec7e9e220e658e9c82a0d40 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 09:59:09 2021 +0300 add unit test to participation_test commit 55a859a3335b00fe37aa6a6300554297d0a3971f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 16:43:58 2021 +0300 changed Signer, Verifier interfaces commit f2750f505086bfa79ef11773967fd59487f061ba Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:43:30 2021 +0300 added to partkeyinfo command print of the compact cert commit 6f63e7de3d39b9b753b8367a3177aa5fb9a115fb Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:42:42 2021 +0300 partKey load function from DB to support new compact cert key commit ef8d14ac9e98b404fa6f09286c56ea0ae66948ca Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:32:27 2021 +0300 changed partMigrate function to support new version commit 9804615e220e3c2753d28727d466a3ed846d8680 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 14:00:57 2021 +0300 persisting participation key will store the a key for compact certificate commit 30419ab4daccbf0ce62cddee18a4dbf5649c6252 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 07:07:14 2021 +0300 changed participation compactCertKey to use the new abstraction commit 7e6b78010f40c80f88c4cc8bf1904e2696b07db0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 07:05:16 2021 +0300 added abstraction to signing keys commit d339a87178b08ede3ac82fea71c7976b768c092a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 20:32:50 2021 +0300 written SignatureAlgorithm and verifyingKey types commit 61b6602d66191e3514c9bec3bedb3e1303b94f1e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 15:12:23 2021 +0300 added compact cert creation to participation struct commit 5dbd0bc610cdfdaa144ca719e165375709351865 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 14:48:18 2021 +0300 wip: added placeholder object to represent key commit 689f9fa08ab0c51a4fda5550067993ea63f4cd6b Merge: 94643c1c 90c132eb Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Thu Jul 15 14:36:48 2021 +0300 Merge pull request #2518 from algonathan/key-reg blockproofkey-registration commit 90c132eb398a895d3a4239489b67bfbbd54b25ad Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 13:35:22 2021 +0300 fix: make lint commit 87a6b0b1cbb3e419d5ebb0bb6ba732b9679eae6f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 11:46:49 2021 +0300 gen generates blockProofPK only once the key is enabled commit 3c9c2bf26b2fa052334ab2435e50f57f7a4e886e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 11:27:02 2021 +0300 corrected apply. added test for current ver and future ver commit ba4ad34c6f8bd25004c61d22f6792c55de71c3c2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 10:57:58 2021 +0300 fix: reused comparision inside blockProofPKWellFormed commit 7ee971e5cb5ba221fd765d3194f28d83594f73d9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 10:55:33 2021 +0300 repositioned the checks for blockproofPK commit 5e5043dbc32a031b311cafdb59f74174bc3b86d0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:33:54 2021 +0300 covered line in wellform check of the blockProofPK commit 17386d3d2d45b1dc74b4a8e99f25d925df3936c5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:27:27 2021 +0300 fix: go fmt commit 4828bb2990530e208b1ab22553ebcd8d58b99659 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 15 07:25:03 2021 +0300 removed unused function commit 2612251ac51485eacedcd93bcf171a6753e309f1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 18:28:59 2021 +0300 keyreg txn creation takes into account the current version commit b6802d58edbf95f8230ac38bc593a3f6c8532072 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 14:28:28 2021 +0300 fix: added to goal network genesis creation function the blockProofID too commit 2e6e2211a663b00c3fb1105ce777ae85327045ad Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 11:48:41 2021 +0300 fix: blockProof wellformed checks that offline keyreg is correct commit 281d01595c57a1b62449032598ef69660906f9d2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 14 11:08:57 2021 +0300 added wellFormed checks for offline commit 030062056d186e4e4d294ee0e679547859b0a13a Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 18:47:53 2021 +0300 shorter codec names for blockProofPKs commit 77d7385a786a53a2fe80af703a01ffff2e2987fa Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 18:43:25 2021 +0300 fix: didn't check offline requests on the blockProofPK commit dd3ad384fd8e97c377a7237202ec30e787d35610 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 11:19:14 2021 +0300 added test that inspects blockProofPK are stored in the account commit 64a2c3b5b2bcd090b9915feb6a038d0270caa0d2 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 12 08:50:32 2021 +0300 fix: correct keyregTXNfields for different version types commit 29c7cef33443cf4f5e71abdce2c0a16339be9654 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 17:35:42 2021 +0300 fix: because WellFormed is run before keyreg - no need to check BlockProofPK inside Keyreg commit 33867e6079a690f5599a623d7a26048c4d70af74 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 16:10:42 2021 +0300 fix: transaction wellformed now checks if blockProofPK is valid commit cae501b6417af8e831728376c1edbdd55de54001 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 16:03:39 2021 +0300 added unit test to keyreg apply commit c57757a97bdf80af7f4453009fe34ebca4645615 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 15:03:50 2021 +0300 added basic support to wellformness of keyReg transaction commit 94643c1cd335e65c13ec4272323888201371dc60 Merge: 415d82cd f00603c4 Author: algoidan <79864820+algoidan@users.noreply.github.com> Date: Sun Jul 11 13:45:08 2021 +0300 Merge pull request #2501 from algonathan/signer add-participation-key-for-compact-cert commit ec56aa26a0f7265142cbfcaf984437b8f09294c9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 13:12:05 2021 +0300 renamed blockProofPK commit 0a0cc84d04fb09e8d2d5d51f1068ff28757ae94c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 14:13:42 2021 +0300 added to structs in data package compact cert keys commit f00603c4c16ee77e1ec11c823ac55f7a17c03804 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 12:55:32 2021 +0300 altered comments commit ee5246ca6b1bb4fbb22b9feffb1d4ad2144aedd5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 12:46:50 2021 +0300 renamed partkeyInfo field commit c79463a84439cddded532dbc865076526e0af7f8 Merge: 3afdb9a7 415d82cd Author: algonathan <85506383+algonathan@users.noreply.github.com> Date: Sun Jul 11 10:21:38 2021 +0300 Merge branch 'algorand:master' into signer commit 3afdb9a72f543e8c7133a2da645c891b34e05c42 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 08:00:46 2021 +0300 added liscenses to new files commit 78cf451315712dcf2a8b20fe2d64af07a7736bb5 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 11 07:52:00 2021 +0300 changed name of compactCert key commit 3b0c35845a70cd6494e7705c94f57e10a54457de Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 19:41:32 2021 +0300 fix: changed comments commit 5e564044e77b88bd9ab315cf3602ab7875710a14 Merge: e649a375 3ac481ec Author: algonathan <85506383+algonathan@users.noreply.github.com> Date: Thu Jul 8 15:11:13 2021 +0300 Merge branch 'algorand:master' into signer commit e649a375371068016f9ac74e3a6b17fd6ae79eeb Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 13:29:02 2021 +0300 interface change commit f69615d02db7746a05ac3aa93804d5fb62f24020 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 11:00:25 2021 +0300 refactor: cleaned if statement commit bc8e0ebc3e2768f55ab7cf462e65a2e2d5476362 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 8 10:48:41 2021 +0300 fix: part.CompactCertSigner returned nil, made certain to inspect that commit b4093f5478396135843a4387b5d9730a9619baeb Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 14:21:00 2021 +0300 added space in a tx.Exec query string commit ecb8871f7907b0daf94bfa9d730edbfa6d9d6ae9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:52:52 2021 +0300 changed subTests into Tests commit f5448f45b4f6d8530af0dd76877639dc7492b4ff Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:44:42 2021 +0300 move variable to test commit 6e952b29dc22d0c0e192be7b1d81d0791038a07c Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:40:49 2021 +0300 changed comment commit 63247238b13aafdf7456e446d31fd2a78765a9f9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:32:16 2021 +0300 fix: did not return error from function commit e0b81094f365a5b6a46118a6ca35f0030ed30f1e Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Wed Jul 7 10:17:18 2021 +0300 fix: bad design in getting verifyingKey commit f50696f0dc4364cfcdd637f1eef46aa31e3e5fbf Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 17:10:06 2021 +0300 changed Verifier interface commit 63f906f3cc9c0093d0dd1609a9a277926a9588ec Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 16:20:20 2021 +0300 added test to retrieve participation keys from an unupdated DB commit 296ab931a5c12aaaf963ea81d4099f95e9d1e37f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 15:09:03 2021 +0300 lint fix commit 76ef7a08c83dd4be8b0bd123254032765b327db6 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 14:14:49 2021 +0300 added migration tests to participation package commit dc13ec58e085ae5fb9b38ee208dee08d0ad225c9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 11:49:35 2021 +0300 fix: bug in migrate, added a unit test to check migration commit dccb6afd22b7c185d99854d532212bdeb6b7935f Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Mon Jul 5 09:59:09 2021 +0300 add unit test to participation_test commit b548391ef9bbb97120aeb6e3fcfe06f8a1a419e1 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 16:43:58 2021 +0300 changed Signer, Verifier interfaces commit 29790394859d2621542c1b58b1a5e56305f15bf9 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:43:30 2021 +0300 added to partkeyinfo command print of the compact cert commit 94e6fdc73f0b7f9b22c8ed460a9013ee7b169ca7 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:42:42 2021 +0300 partKey load function from DB to support new compact cert key commit b3a6c214f5523c6deb120da0c3a26843994dcc28 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 15:32:27 2021 +0300 changed partMigrate function to support new version commit c2432d7f7aa6f8bd2224b1e2210ea86fd6f086d0 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 14:00:57 2021 +0300 persisting participation key will store the a key for compact certificate commit 2e003a405dc00d84b96815a54e5de266ec770a29 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 07:07:14 2021 +0300 changed participation compactCertKey to use the new abstraction commit 5016ab1a397e5895660e1b788bcadf23cfac7f4d Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Sun Jul 4 07:05:16 2021 +0300 added abstraction to signing keys commit a04011fe612f8fbf29954e2ebb60cbe360d23e49 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 20:32:50 2021 +0300 written SignatureAlgorithm and verifyingKey types commit 63f8a81c8c690903813284e794f94a35ce9b9016 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 15:12:23 2021 +0300 added compact cert creation to participation struct commit 5fff52dc72de06e6324c8978c42ab6369c5f9016 Author: Jonathan Weiss <jonathan.weiss@algorand.com> Date: Thu Jul 1 14:48:18 2021 +0300 wip: added placeholder object to represent key
Diffstat
-rw-r--r--Makefile2
-rw-r--r--cmd/goal/account.go10
-rw-r--r--compactcert/db.go4
-rw-r--r--compactcert/signer.go48
-rw-r--r--compactcert/worker_test.go34
-rw-r--r--config/consensus.go6
-rw-r--r--crypto/compactcert/builder.go37
-rw-r--r--crypto/compactcert/builder_test.go103
-rw-r--r--crypto/compactcert/common.go12
-rw-r--r--crypto/compactcert/common_test.go12
-rw-r--r--crypto/compactcert/const.go35
-rw-r--r--crypto/compactcert/msgp_gen.go422
-rw-r--r--crypto/compactcert/structs.go27
-rw-r--r--crypto/compactcert/verifier.go41
-rw-r--r--crypto/curve25519.go4
-rw-r--r--crypto/curve25519_wrapper.go82
-rw-r--r--crypto/digest.go44
-rw-r--r--crypto/dillithium.go97
-rw-r--r--crypto/dillithium_test.go83
-rw-r--r--crypto/hashes.go92
-rw-r--r--crypto/hashes_test.go62
-rw-r--r--crypto/merklearray/array.go10
-rw-r--r--crypto/merklearray/layer.go58
-rw-r--r--crypto/merklearray/layer_test.go9
-rw-r--r--crypto/merklearray/merkle.go215
-rw-r--r--crypto/merklearray/merkle_test.go233
-rw-r--r--crypto/merklearray/msgp_gen.go488
-rw-r--r--crypto/merklearray/msgp_gen_test.go193
-rw-r--r--crypto/merklearray/partial.go36
-rw-r--r--crypto/merklearray/worker.go5
-rw-r--r--crypto/merklekeystore/const.go25
-rw-r--r--crypto/merklekeystore/keystore.go295
-rw-r--r--crypto/merklekeystore/keystore_test.go463
-rw-r--r--crypto/merklekeystore/msgp_gen.go730
-rw-r--r--crypto/merklekeystore/msgp_gen_test.go253
-rw-r--r--crypto/merklekeystore/posdivs.go25
-rw-r--r--crypto/msgp_gen.go2148
-rw-r--r--crypto/msgp_gen_test.go660
-rw-r--r--crypto/onetimesig.go16
-rw-r--r--crypto/sig_abstractions.go166
-rw-r--r--crypto/util.go15
-rw-r--r--crypto/vrf.go4
-rw-r--r--daemon/algod/api/server/v1/handlers/handlers.go2
-rw-r--r--daemon/algod/api/server/v2/handlers.go2
-rw-r--r--data/account/account.go19
-rw-r--r--data/account/partInstall.go47
-rw-r--r--data/account/participation.go33
-rw-r--r--data/account/participation_test.go320
-rw-r--r--data/accountManager.go1
-rw-r--r--data/basics/ccertpart.go11
-rw-r--r--data/basics/msgp_gen.go168
-rw-r--r--data/basics/userBalance.go6
-rw-r--r--data/bookkeeping/block.go4
-rw-r--r--data/bookkeeping/txn_merkle.go31
-rw-r--r--data/bookkeeping/txn_merkle_test.go6
-rw-r--r--data/pools/transactionPool.go1
-rw-r--r--data/transactions/compactcert.go4
-rw-r--r--data/transactions/keyreg.go2
-rw-r--r--data/transactions/msgp_gen.go186
-rw-r--r--data/transactions/transaction.go44
-rw-r--r--data/transactions/transaction_test.go116
-rw-r--r--gen/generate.go3
-rw-r--r--gen/walletData.go2
-rw-r--r--go.mod28
-rw-r--r--go.sum23
-rw-r--r--ledger/accountdb.go3
-rw-r--r--ledger/accountdb_test.go53
-rw-r--r--ledger/apply/keyreg.go3
-rw-r--r--ledger/apply/keyreg_test.go77
-rw-r--r--ledger/internal/compactcert.go9
-rw-r--r--ledger/internal/compactcert_test.go2
-rw-r--r--ledger/internal/eval.go4
-rw-r--r--ledger/ledger_test.go13
-rw-r--r--ledger/ledgercore/misc.go14
-rw-r--r--ledger/ledgercore/onlineacct.go5
-rw-r--r--ledger/ledgercore/votersForRound.go15
-rw-r--r--ledger/testing/randomAccounts.go5
-rw-r--r--libgoal/participation.go3
-rw-r--r--libgoal/transactions.go2
-rw-r--r--protocol/hash.go2
-rw-r--r--test/e2e-go/features/compactcert/compactcert_test.go3
-rw-r--r--test/e2e-go/features/participation/overlappingParticipationKeys_test.go7
-rw-r--r--test/e2e-go/features/transactions/proof_test.go36
-rw-r--r--test/e2e-go/upgrades/send_receive_upgrade_test.go18
-rw-r--r--test/e2e-go/upgrades/stateproof_test.go160
-rw-r--r--test/testdata/nettemplates/TwoNodesWithoutStateProofPartkeys.json40
-rw-r--r--test/testdata/nettemplates/UpgradeIntoCompactCert.json41
-rw-r--r--txnsync/encodedgroupsmarshalers.go42
-rw-r--r--txnsync/encodedgroupstypes.go18
-rw-r--r--txnsync/encodedgroupsunmarshalers.go34
-rw-r--r--txnsync/msgp_gen.go21345
-rw-r--r--txnsync/txngroups_test.go18
92 files changed, 19554 insertions, 10781 deletions
diff --git a/Makefile b/Makefile
index 77a965887..6a75402d9 100644
--- a/Makefile
+++ b/Makefile
@@ -76,7 +76,7 @@ GOLDFLAGS := $(GOLDFLAGS_BASE) \
UNIT_TEST_SOURCES := $(sort $(shell GOPATH=$(GOPATH) && GO111MODULE=off && go list ./... | grep -v /go-algorand/test/ ))
ALGOD_API_PACKAGES := $(sort $(shell GOPATH=$(GOPATH) && GO111MODULE=off && cd daemon/algod/api; go list ./... ))
-MSGP_GENERATE := ./protocol ./protocol/test ./crypto ./crypto/compactcert ./data/basics ./data/transactions ./data/committee ./data/bookkeeping ./data/hashable ./agreement ./rpcs ./node ./ledger ./ledger/ledgercore ./compactcert ./txnsync ./data/pooldata
+MSGP_GENERATE := ./protocol ./protocol/test ./crypto ./crypto/merklearray ./crypto/merklekeystore ./crypto/compactcert ./data/basics ./data/transactions ./data/committee ./data/bookkeeping ./data/hashable ./agreement ./rpcs ./node ./ledger ./ledger/ledgercore ./compactcert ./txnsync ./data/pooldata
default: build
diff --git a/cmd/goal/account.go b/cmd/goal/account.go
index d1bf2f6cf..04769f38f 100644
--- a/cmd/goal/account.go
+++ b/cmd/goal/account.go
@@ -26,10 +26,9 @@ import (
"sort"
"strings"
- "github.com/spf13/cobra"
-
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/crypto/passphrase"
generatedV2 "github.com/algorand/go-algorand/daemon/algod/api/server/v2/generated"
algodAcct "github.com/algorand/go-algorand/data/account"
@@ -39,6 +38,8 @@ import (
"github.com/algorand/go-algorand/protocol"
"github.com/algorand/go-algorand/util"
"github.com/algorand/go-algorand/util/db"
+
+ "github.com/spf13/cobra"
)
var (
@@ -1283,6 +1284,7 @@ type partkeyInfo struct {
LastValid basics.Round `codec:"last"`
VoteID crypto.OneTimeSignatureVerifier `codec:"vote"`
SelectionID crypto.VRFVerifier `codec:"sel"`
+ BlockProofID merklekeystore.Verifier `codec:"blkprf"`
VoteKeyDilution uint64 `codec:"voteKD"`
}
@@ -1305,6 +1307,7 @@ var partkeyInfoCmd = &cobra.Command{
for filename, part := range parts {
fmt.Println("------------------------------------------------------------------")
+
info := partkeyInfo{
Address: part.Address().String(),
FirstValid: part.FirstValid,
@@ -1313,6 +1316,9 @@ var partkeyInfoCmd = &cobra.Command{
SelectionID: part.VRFSecrets().PK,
VoteKeyDilution: part.KeyDilution,
}
+ if certSigner := part.BlockProofSigner(); certSigner != nil {
+ info.BlockProofID = *certSigner.GetVerifier()
+ }
infoString := protocol.EncodeJSON(&info)
fmt.Printf("File: %s\n%s\n", filename, string(infoString))
}
diff --git a/compactcert/db.go b/compactcert/db.go
index ee933c69d..3305f92d6 100644
--- a/compactcert/db.go
+++ b/compactcert/db.go
@@ -20,7 +20,7 @@ import (
"database/sql"
"fmt"
- "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/protocol"
)
@@ -47,7 +47,7 @@ var schema = []string{
type pendingSig struct {
signer basics.Address
- sig crypto.OneTimeSignature
+ sig merklekeystore.Signature
fromThisNode bool
}
diff --git a/compactcert/signer.go b/compactcert/signer.go
index 767211130..9c41fe8ee 100644
--- a/compactcert/signer.go
+++ b/compactcert/signer.go
@@ -22,7 +22,7 @@ import (
"time"
"github.com/algorand/go-algorand/config"
- "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/bookkeeping"
"github.com/algorand/go-algorand/protocol"
@@ -34,9 +34,9 @@ import (
type sigFromAddr struct {
_struct struct{} `codec:",omitempty,omitemptyarray"`
- Signer basics.Address `codec:"signer"`
- Round basics.Round `codec:"rnd"`
- Sig crypto.OneTimeSignature `codec:"sig"`
+ Signer basics.Address `codec:"signer"`
+ Round basics.Round `codec:"rnd"`
+ Sig merklekeystore.Signature `codec:"sig"`
}
func (ccw *Worker) signer(latest basics.Round) {
@@ -93,12 +93,7 @@ func (ccw *Worker) signBlock(hdr bookkeeping.BlockHeader) {
return
}
- // Compact cert gets signed by the next round after the block,
- // because by the time agreement is reached on the block,
- // ephemeral keys for that round could be deleted.
- sigKeyRound := hdr.Round + 1
-
- keys := ccw.accts.Keys(sigKeyRound)
+ keys := ccw.accts.Keys(hdr.Round)
if len(keys) == 0 {
// No keys, nothing to do.
return
@@ -113,33 +108,30 @@ func (ccw *Worker) signBlock(hdr bookkeeping.BlockHeader) {
return
}
- if votersHdr.CompactCert[protocol.CompactCertBasic].CompactCertVoters.IsZero() {
+ if votersHdr.CompactCert[protocol.CompactCertBasic].CompactCertVoters.IsEmpty() {
// No voter commitment, perhaps because compact certs were
// just enabled.
return
}
- votersProto := config.Consensus[votersHdr.CurrentProtocol]
+ sigs := make([]sigFromAddr, 0, len(keys))
- var sigs []sigFromAddr
- var sigkeys []crypto.OneTimeSignatureVerifier
for _, key := range keys {
- if key.FirstValid <= sigKeyRound && sigKeyRound <= key.LastValid {
- keyDilution := key.KeyDilution
- if keyDilution == 0 {
- keyDilution = votersProto.DefaultKeyDilution
- }
-
- ephID := basics.OneTimeIDForRound(sigKeyRound, keyDilution)
- sig := key.Voting.Sign(ephID, hdr)
+ if key.FirstValid > hdr.Round || hdr.Round > key.LastValid {
+ continue
+ }
- sigs = append(sigs, sigFromAddr{
- Signer: key.Parent,
- Round: hdr.Round,
- Sig: sig,
- })
- sigkeys = append(sigkeys, key.Voting.OneTimeSignatureVerifier)
+ sig, err := key.BlockProof.Sign(hdr, uint64(hdr.Round))
+ if err != nil {
+ ccw.log.Warnf("ccw.signBlock(%d): BlockProof.Sign: %v", hdr.Round, err)
+ continue
}
+
+ sigs = append(sigs, sigFromAddr{
+ Signer: key.Parent,
+ Round: hdr.Round,
+ Sig: sig,
+ })
}
for _, sfa := range sigs {
diff --git a/compactcert/worker_test.go b/compactcert/worker_test.go
index adc784f0e..6e645f920 100644
--- a/compactcert/worker_test.go
+++ b/compactcert/worker_test.go
@@ -77,7 +77,11 @@ func (s *testWorkerStubs) addBlock(ccNextRound basics.Round) {
hdr.Round = s.latest
hdr.CurrentProtocol = protocol.ConsensusFuture
- var ccBasic bookkeeping.CompactCertState
+ var ccBasic = bookkeeping.CompactCertState{
+ CompactCertVoters: make([]byte, compactcert.HashSize),
+ CompactCertVotersTotal: basics.MicroAlgos{},
+ CompactCertNextRound: 0,
+ }
ccBasic.CompactCertVotersTotal.Raw = uint64(s.totalWeight)
if hdr.Round > 0 {
@@ -131,13 +135,13 @@ func (s *testWorkerStubs) CompactCertVoters(r basics.Round) (*ledgercore.VotersF
for i, k := range s.keysForVoters {
voters.AddrToPos[k.Parent] = uint64(i)
voters.Participants = append(voters.Participants, basics.Participant{
- PK: k.Voting.OneTimeSignatureVerifier,
- Weight: 1,
- KeyDilution: config.Consensus[protocol.ConsensusFuture].DefaultKeyDilution,
+ PK: *k.BlockProof.GetVerifier(),
+ Weight: 1,
+ FirstValid: uint64(k.FirstValid),
})
}
- tree, err := merklearray.Build(voters.Participants)
+ tree, err := merklearray.Build(voters.Participants, crypto.HashFactory{HashType: crypto.Sha512_256})
if err != nil {
return nil, err
}
@@ -206,7 +210,7 @@ func newPartKey(t testing.TB, parent basics.Address) account.Participation {
partDB, err := db.MakeAccessor(fn, false, true)
require.NoError(t, err)
- part, err := account.FillDBWithParticipationKeys(partDB, parent, 0, 1024*1024, config.Consensus[protocol.ConsensusFuture].DefaultKeyDilution)
+ part, err := account.FillDBWithParticipationKeys(partDB, parent, 0, 1024, config.Consensus[protocol.ConsensusFuture].DefaultKeyDilution)
require.NoError(t, err)
part.Close()
return part.Participation
@@ -257,10 +261,11 @@ func TestWorkerAllSigs(t *testing.T) {
require.False(t, overflowed)
ccparams := compactcert.Params{
- Msg: signedHdr,
- ProvenWeight: provenWeight,
- SigRound: basics.Round(signedHdr.Round + 1),
- SecKQ: proto.CompactCertSecKQ,
+ Msg: signedHdr,
+ ProvenWeight: provenWeight,
+ SigRound: basics.Round(signedHdr.Round),
+ SecKQ: proto.CompactCertSecKQ,
+ CompactCertRounds: proto.CompactCertRounds,
}
voters, err := s.CompactCertVoters(tx.Txn.CertRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))
@@ -318,10 +323,11 @@ func TestWorkerPartialSigs(t *testing.T) {
require.False(t, overflowed)
ccparams := compactcert.Params{
- Msg: signedHdr,
- ProvenWeight: provenWeight,
- SigRound: basics.Round(signedHdr.Round + 1),
- SecKQ: proto.CompactCertSecKQ,
+ Msg: signedHdr,
+ ProvenWeight: provenWeight,
+ SigRound: basics.Round(signedHdr.Round),
+ SecKQ: proto.CompactCertSecKQ,
+ CompactCertRounds: proto.CompactCertRounds,
}
voters, err := s.CompactCertVoters(tx.Txn.CertRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))
diff --git a/config/consensus.go b/config/consensus.go
index f0ffa1a51..4ee9b2f15 100644
--- a/config/consensus.go
+++ b/config/consensus.go
@@ -395,6 +395,9 @@ type ConsensusParams struct {
// MaxProposedExpiredOnlineAccounts is the maximum number of online accounts, which need
// to be taken offline, that would be proposed to be taken offline.
MaxProposedExpiredOnlineAccounts int
+
+ // EnableBlockProofKeyregCheck enables the check for blockProof key on key registration
+ EnableBlockProofKeyregCheck bool
}
// PaysetCommitType enumerates possible ways for the block header to commit to
@@ -1056,6 +1059,9 @@ func initConsensusProtocols() {
vFuture.MaxProposedExpiredOnlineAccounts = 32
+ // compact certificate key registration
+ vFuture.EnableBlockProofKeyregCheck = true
+
Consensus[protocol.ConsensusFuture] = vFuture
}
diff --git a/crypto/compactcert/builder.go b/crypto/compactcert/builder.go
index 5966ca9a7..30cf20bdd 100644
--- a/crypto/compactcert/builder.go
+++ b/crypto/compactcert/builder.go
@@ -18,10 +18,11 @@ package compactcert
import (
"fmt"
+ "github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/crypto/merklearray"
- "github.com/algorand/go-algorand/data/basics"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
)
//msgp:ignore sigslot
@@ -81,7 +82,7 @@ func (b *Builder) Present(pos uint64) bool {
// Add a signature to the set of signatures available for building a certificate.
// verifySig should be set to true in production; setting it to false is useful
// for benchmarking to avoid the cost of signature checks.
-func (b *Builder) Add(pos uint64, sig crypto.OneTimeSignature, verifySig bool) error {
+func (b *Builder) Add(pos uint64, sig merklekeystore.Signature, verifySig bool) error {
if b.Present(pos) {
return fmt.Errorf("position %d already added", pos)
}
@@ -98,14 +99,16 @@ func (b *Builder) Add(pos uint64, sig crypto.OneTimeSignature, verifySig bool) e
}
// Check signature
- ephID := basics.OneTimeIDForRound(b.SigRound, p.KeyDilution)
- if verifySig && !p.PK.Verify(ephID, b.Msg, sig) {
- return fmt.Errorf("signature does not verify under ID %v", ephID)
+
+ if verifySig {
+ if err := p.PK.Verify(p.FirstValid, uint64(b.SigRound), b.CompactCertRounds, b.Msg, sig); err != nil {
+ return err
+ }
}
// Remember the signature
b.sigs[pos].Weight = p.Weight
- b.sigs[pos].Sig.OneTimeSignature = sig
+ b.sigs[pos].Sig.Signature = sig
b.signedWeight += p.Weight
b.cert = nil
b.sigsHasValidL = false
@@ -129,12 +132,12 @@ func (sc sigsToCommit) Length() uint64 {
return uint64(len(sc))
}
-func (sc sigsToCommit) GetHash(pos uint64) (crypto.Digest, error) {
+func (sc sigsToCommit) Marshal(pos uint64) ([]byte, error) {
if pos >= uint64(len(sc)) {
- return crypto.Digest{}, fmt.Errorf("pos %d past end %d", pos, len(sc))
+ return nil, fmt.Errorf("pos %d past end %d", pos, len(sc))
}
- return crypto.HashObj(&sc[pos].sigslotCommit), nil
+ return crypto.HashRep(&sc[pos].sigslotCommit), nil
}
// coinIndex returns the position pos in the sigs array such that the sum
@@ -187,7 +190,8 @@ func (b *Builder) Build() (*Cert, error) {
}
b.sigsHasValidL = true
- sigtree, err := merklearray.Build(sigsToCommit(b.sigs))
+ hfactory := crypto.HashFactory{HashType: HashType}
+ sigtree, err := merklearray.Build(sigsToCommit(b.sigs), hfactory)
if err != nil {
return nil, err
}
@@ -205,7 +209,11 @@ func (b *Builder) Build() (*Cert, error) {
}
var proofPositions []uint64
- msgHash := crypto.HashObj(b.Msg)
+ hash, err := hfactory.NewHash()
+ if err != nil {
+ return nil, err
+ }
+ msgHash := crypto.GenereicHashObj(hash, b.Msg)
for j := uint64(0); j < nr; j++ {
choice := coinChoice{
@@ -242,15 +250,18 @@ func (b *Builder) Build() (*Cert, error) {
proofPositions = append(proofPositions, pos)
}
- c.SigProofs, err = sigtree.Prove(proofPositions)
+ sigProofs, err := sigtree.Prove(proofPositions)
if err != nil {
return nil, err
}
- c.PartProofs, err = b.parttree.Prove(proofPositions)
+ partProofs, err := b.parttree.Prove(proofPositions)
if err != nil {
return nil, err
}
+ c.SigProofs = *sigProofs
+ c.PartProofs = *partProofs
+
return c, nil
}
diff --git a/crypto/compactcert/builder_test.go b/crypto/compactcert/builder_test.go
index 13738b5c3..c31799d88 100644
--- a/crypto/compactcert/builder_test.go
+++ b/crypto/compactcert/builder_test.go
@@ -22,6 +22,7 @@ import (
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/crypto/merklearray"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/protocol"
@@ -43,17 +44,33 @@ func (pc PartCommit) Length() uint64 {
return uint64(len(pc.participants))
}
-func (pc PartCommit) GetHash(pos uint64) (crypto.Digest, error) {
+func (pc PartCommit) Marshal(pos uint64) ([]byte, error) {
if pos >= uint64(len(pc.participants)) {
- return crypto.Digest{}, fmt.Errorf("pos %d >= len %d", pos, len(pc.participants))
+ return nil, fmt.Errorf("pos %d >= len %d", pos, len(pc.participants))
}
- return crypto.HashObj(pc.participants[pos]), nil
+ return crypto.HashRep(pc.participants[pos]), nil
+}
+
+func createParticipantSliceWithWeight(totalWeight, numberOfParticipant int, key *merklekeystore.Signer) []basics.Participant {
+ parts := make([]basics.Participant, 0, numberOfParticipant)
+
+ for i := 0; i < numberOfParticipant; i++ {
+ part := basics.Participant{
+ PK: *key.GetVerifier(),
+ Weight: uint64(totalWeight / 2 / numberOfParticipant),
+ FirstValid: 0,
+ }
+
+ parts = append(parts, part)
+ }
+ return parts
}
func TestBuildVerify(t *testing.T) {
partitiontest.PartitionTest(t)
+ currentRound := basics.Round(128)
// Doing a full test of 1M accounts takes too much CPU time in CI.
doLargeTest := false
@@ -69,45 +86,31 @@ func TestBuildVerify(t *testing.T) {
npart := npartHi + npartLo
param := Params{
- Msg: TestMessage("hello world"),
- ProvenWeight: uint64(totalWeight / 2),
- SigRound: 0,
- SecKQ: 128,
+ Msg: TestMessage("hello world"),
+ ProvenWeight: uint64(totalWeight / 2),
+ SigRound: currentRound,
+ SecKQ: 128,
+ CompactCertRounds: 128,
}
// Share the key; we allow the same vote key to appear in multiple accounts..
- key := crypto.GenerateOneTimeSignatureSecrets(0, 1)
-
- var parts []basics.Participant
- var sigs []crypto.OneTimeSignature
- for i := 0; i < npartHi; i++ {
- part := basics.Participant{
- PK: key.OneTimeSignatureVerifier,
- Weight: uint64(totalWeight / 2 / npartHi),
- KeyDilution: 10000,
- }
+ key, err := merklekeystore.New(0, uint64(param.CompactCertRounds)+1, param.CompactCertRounds, crypto.Ed25519Type)
- parts = append(parts, part)
- }
-
- for i := 0; i < npartLo; i++ {
- part := basics.Participant{
- PK: key.OneTimeSignatureVerifier,
- Weight: uint64(totalWeight / 2 / npartLo),
- KeyDilution: 10000,
- }
+ require.NoError(t, err, "failed to create keys")
- parts = append(parts, part)
- }
+ var parts []basics.Participant
+ var sigs []merklekeystore.Signature
+ parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartHi, key)...)
+ parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartLo, key)...)
- ephID := basics.OneTimeIDForRound(0, parts[0].KeyDilution)
- sig := key.Sign(ephID, param.Msg)
+ sig, err := key.Sign(param.Msg, uint64(currentRound))
+ require.NoError(t, err, "failed to create keys")
for i := 0; i < npart; i++ {
sigs = append(sigs, sig)
}
- partcom, err := merklearray.Build(PartCommit{parts})
+ partcom, err := merklearray.Build(PartCommit{parts}, crypto.HashFactory{HashType: HashType})
if err != nil {
t.Error(err)
}
@@ -137,7 +140,7 @@ func TestBuildVerify(t *testing.T) {
certenc := protocol.Encode(cert)
fmt.Printf("Cert size:\n")
- fmt.Printf(" %6d elems sigproofs\n", len(cert.SigProofs))
+ fmt.Printf(" %6d elems sigproofs\n", len(cert.SigProofs.Path))
fmt.Printf(" %6d bytes sigproofs\n", len(protocol.EncodeReflect(cert.SigProofs)))
fmt.Printf(" %6d bytes partproofs\n", len(protocol.EncodeReflect(cert.PartProofs)))
fmt.Printf(" %6d bytes sigproof per reveal\n", len(protocol.EncodeReflect(cert.SigProofs))/len(cert.Reveals))
@@ -149,35 +152,36 @@ func TestBuildVerify(t *testing.T) {
verif := MkVerifier(param, partcom.Root())
err = verif.Verify(cert)
- if err != nil {
- t.Error(err)
- }
+ require.NoError(t, err, "failed to verify the compact cert")
}
func BenchmarkBuildVerify(b *testing.B) {
totalWeight := 1000000
npart := 10000
+ currentRound := basics.Round(128)
param := Params{
- Msg: TestMessage("hello world"),
- ProvenWeight: uint64(totalWeight / 2),
- SigRound: 0,
- SecKQ: 128,
+ Msg: TestMessage("hello world"),
+ ProvenWeight: uint64(totalWeight / 2),
+ SigRound: 128,
+ SecKQ: 128,
+ CompactCertRounds: 128,
}
var parts []basics.Participant
- var partkeys []*crypto.OneTimeSignatureSecrets
- var sigs []crypto.OneTimeSignature
+ var partkeys []*merklekeystore.Signer
+ var sigs []merklekeystore.Signature
for i := 0; i < npart; i++ {
- key := crypto.GenerateOneTimeSignatureSecrets(0, 1)
+ key, err := merklekeystore.New(0, uint64(param.CompactCertRounds)+1, param.CompactCertRounds, crypto.Ed25519Type)
+ require.NoError(b, err, "failed to generate keys")
part := basics.Participant{
- PK: key.OneTimeSignatureVerifier,
- Weight: uint64(totalWeight / npart),
- KeyDilution: 10000,
+ PK: *key.GetVerifier(),
+ Weight: uint64(totalWeight / npart),
+ FirstValid: 0,
}
- ephID := basics.OneTimeIDForRound(0, part.KeyDilution)
- sig := key.Sign(ephID, param.Msg)
+ sig, err := key.Sign(param.Msg, uint64(currentRound))
+ require.NoError(b, err, "failed to create keys")
partkeys = append(partkeys, key)
sigs = append(sigs, sig)
@@ -185,7 +189,7 @@ func BenchmarkBuildVerify(b *testing.B) {
}
var cert *Cert
- partcom, err := merklearray.Build(PartCommit{parts})
+ partcom, err := merklearray.Build(PartCommit{parts}, crypto.HashFactory{HashType: HashType})
if err != nil {
b.Error(err)
}
@@ -214,8 +218,7 @@ func BenchmarkBuildVerify(b *testing.B) {
b.Run("Verify", func(b *testing.B) {
for i := 0; i < b.N; i++ {
verif := MkVerifier(param, partcom.Root())
- err = verif.Verify(cert)
- if err != nil {
+ if err = verif.Verify(cert); err != nil {
b.Error(err)
}
}
diff --git a/crypto/compactcert/common.go b/crypto/compactcert/common.go
index 53b469bfd..38b863ead 100644
--- a/crypto/compactcert/common.go
+++ b/crypto/compactcert/common.go
@@ -29,12 +29,12 @@ import (
type coinChoice struct {
_struct struct{} `codec:",omitempty,omitemptyarray"`
- J uint64 `codec:"j"`
- SignedWeight uint64 `codec:"sigweight"`
- ProvenWeight uint64 `codec:"provenweight"`
- Sigcom crypto.Digest `codec:"sigcom"`
- Partcom crypto.Digest `codec:"partcom"`
- MsgHash crypto.Digest `codec:"msghash"`
+ J uint64 `codec:"j"`
+ SignedWeight uint64 `codec:"sigweight"`
+ ProvenWeight uint64 `codec:"provenweight"`
+ Sigcom crypto.GenericDigest `codec:"sigcom"`
+ Partcom crypto.GenericDigest `codec:"partcom"`
+ MsgHash crypto.GenericDigest `codec:"msghash"`
}
// ToBeHashed implements the crypto.Hashable interface.
diff --git a/crypto/compactcert/common_test.go b/crypto/compactcert/common_test.go
index ce26e4c15..c01926649 100644
--- a/crypto/compactcert/common_test.go
+++ b/crypto/compactcert/common_test.go
@@ -27,9 +27,9 @@ func TestHashCoin(t *testing.T) {
partitiontest.PartitionTest(t)
var slots [32]uint64
- var sigcom [32]byte
- var partcom [32]byte
- var msgHash crypto.Digest
+ var sigcom = make(crypto.GenericDigest, HashSize)
+ var partcom = make(crypto.GenericDigest, HashSize)
+ var msgHash = make(crypto.GenericDigest, HashSize)
crypto.RandBytes(sigcom[:])
crypto.RandBytes(partcom[:])
@@ -64,9 +64,9 @@ func TestHashCoin(t *testing.T) {
}
func BenchmarkHashCoin(b *testing.B) {
- var sigcom [32]byte
- var partcom [32]byte
- var msgHash crypto.Digest
+ var sigcom = make(crypto.GenericDigest, HashSize)
+ var partcom = make(crypto.GenericDigest, HashSize)
+ var msgHash = make(crypto.GenericDigest, HashSize)
crypto.RandBytes(sigcom[:])
crypto.RandBytes(partcom[:])
diff --git a/crypto/compactcert/const.go b/crypto/compactcert/const.go
new file mode 100644
index 000000000..26c1ed83b
--- /dev/null
+++ b/crypto/compactcert/const.go
@@ -0,0 +1,35 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package compactcert
+
+import (
+ "github.com/algorand/go-algorand/crypto"
+)
+
+// HashType/ hashSize relate to the type of hash this package uses.
+const (
+ HashType = crypto.Sha512_256
+ HashSize = crypto.Sha512_256Size
+)
+
+const (
+ // MaxReveals is a bound on allocation and on numReveals to limit log computation
+ MaxReveals = 1024
+
+ // MaxProofDigests is a bound on allocation on number of proofs
+ MaxProofDigests = 20 * MaxReveals
+)
diff --git a/crypto/compactcert/msgp_gen.go b/crypto/compactcert/msgp_gen.go
index de366c139..0f836ebcc 100644
--- a/crypto/compactcert/msgp_gen.go
+++ b/crypto/compactcert/msgp_gen.go
@@ -5,7 +5,6 @@ package compactcert
import (
"sort"
- "github.com/algorand/go-algorand/crypto"
"github.com/algorand/msgp/msgp"
)
@@ -55,61 +54,47 @@ import (
func (z *Cert) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0005Len := uint32(5)
- var zb0005Mask uint8 /* 6 bits */
- if len((*z).PartProofs) == 0 {
- zb0005Len--
- zb0005Mask |= 0x1
+ zb0003Len := uint32(5)
+ var zb0003Mask uint8 /* 6 bits */
+ if (*z).PartProofs.MsgIsZero() {
+ zb0003Len--
+ zb0003Mask |= 0x1
}
- if len((*z).SigProofs) == 0 {
- zb0005Len--
- zb0005Mask |= 0x2
+ if (*z).SigProofs.MsgIsZero() {
+ zb0003Len--
+ zb0003Mask |= 0x2
}
if (*z).SigCommit.MsgIsZero() {
- zb0005Len--
- zb0005Mask |= 0x8
+ zb0003Len--
+ zb0003Mask |= 0x8
}
if len((*z).Reveals) == 0 {
- zb0005Len--
- zb0005Mask |= 0x10
+ zb0003Len--
+ zb0003Mask |= 0x10
}
if (*z).SignedWeight == 0 {
- zb0005Len--
- zb0005Mask |= 0x20
+ zb0003Len--
+ zb0003Mask |= 0x20
}
- // variable map header, size zb0005Len
- o = append(o, 0x80|uint8(zb0005Len))
- if zb0005Len != 0 {
- if (zb0005Mask & 0x1) == 0 { // if not empty
+ // variable map header, size zb0003Len
+ o = append(o, 0x80|uint8(zb0003Len))
+ if zb0003Len != 0 {
+ if (zb0003Mask & 0x1) == 0 { // if not empty
// string "P"
o = append(o, 0xa1, 0x50)
- if (*z).PartProofs == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).PartProofs)))
- }
- for zb0002 := range (*z).PartProofs {
- o = (*z).PartProofs[zb0002].MarshalMsg(o)
- }
+ o = (*z).PartProofs.MarshalMsg(o)
}
- if (zb0005Mask & 0x2) == 0 { // if not empty
+ if (zb0003Mask & 0x2) == 0 { // if not empty
// string "S"
o = append(o, 0xa1, 0x53)
- if (*z).SigProofs == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).SigProofs)))
- }
- for zb0001 := range (*z).SigProofs {
- o = (*z).SigProofs[zb0001].MarshalMsg(o)
- }
+ o = (*z).SigProofs.MarshalMsg(o)
}
- if (zb0005Mask & 0x8) == 0 { // if not empty
+ if (zb0003Mask & 0x8) == 0 { // if not empty
// string "c"
o = append(o, 0xa1, 0x63)
o = (*z).SigCommit.MarshalMsg(o)
}
- if (zb0005Mask & 0x10) == 0 { // if not empty
+ if (zb0003Mask & 0x10) == 0 { // if not empty
// string "r"
o = append(o, 0xa1, 0x72)
if (*z).Reveals == nil {
@@ -117,19 +102,19 @@ func (z *Cert) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendMapHeader(o, uint32(len((*z).Reveals)))
}
- zb0003_keys := make([]uint64, 0, len((*z).Reveals))
- for zb0003 := range (*z).Reveals {
- zb0003_keys = append(zb0003_keys, zb0003)
+ zb0001_keys := make([]uint64, 0, len((*z).Reveals))
+ for zb0001 := range (*z).Reveals {
+ zb0001_keys = append(zb0001_keys, zb0001)
}
- sort.Sort(SortUint64(zb0003_keys))
- for _, zb0003 := range zb0003_keys {
- zb0004 := (*z).Reveals[zb0003]
- _ = zb0004
- o = msgp.AppendUint64(o, zb0003)
- o = zb0004.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0001_keys))
+ for _, zb0001 := range zb0001_keys {
+ zb0002 := (*z).Reveals[zb0001]
+ _ = zb0002
+ o = msgp.AppendUint64(o, zb0001)
+ o = zb0002.MarshalMsg(o)
}
}
- if (zb0005Mask & 0x20) == 0 { // if not empty
+ if (zb0003Mask & 0x20) == 0 { // if not empty
// string "w"
o = append(o, 0xa1, 0x77)
o = msgp.AppendUint64(o, (*z).SignedWeight)
@@ -147,127 +132,85 @@ func (_ *Cert) CanMarshalMsg(z interface{}) bool {
func (z *Cert) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0005 int
- var zb0006 bool
- zb0005, zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0003 int
+ var zb0004 bool
+ zb0003, zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0005, zb0006, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0003, zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0005 > 0 {
- zb0005--
+ if zb0003 > 0 {
+ zb0003--
bts, err = (*z).SigCommit.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
}
- if zb0005 > 0 {
- zb0005--
+ if zb0003 > 0 {
+ zb0003--
(*z).SignedWeight, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
}
- if zb0005 > 0 {
- zb0005--
- var zb0007 int
- var zb0008 bool
- zb0007, zb0008, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0003 > 0 {
+ zb0003--
+ bts, err = (*z).SigProofs.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0007 > MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0007), uint64(MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs")
- return
- }
- if zb0008 {
- (*z).SigProofs = nil
- } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0007 {
- (*z).SigProofs = ((*z).SigProofs)[:zb0007]
- } else {
- (*z).SigProofs = make([]crypto.Digest, zb0007)
- }
- for zb0001 := range (*z).SigProofs {
- bts, err = (*z).SigProofs[zb0001].UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0001)
- return
- }
- }
}
- if zb0005 > 0 {
- zb0005--
- var zb0009 int
- var zb0010 bool
- zb0009, zb0010, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0003 > 0 {
+ zb0003--
+ bts, err = (*z).PartProofs.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0009 > MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0009), uint64(MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs")
- return
- }
- if zb0010 {
- (*z).PartProofs = nil
- } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0009 {
- (*z).PartProofs = ((*z).PartProofs)[:zb0009]
- } else {
- (*z).PartProofs = make([]crypto.Digest, zb0009)
- }
- for zb0002 := range (*z).PartProofs {
- bts, err = (*z).PartProofs[zb0002].UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0002)
- return
- }
- }
}
- if zb0005 > 0 {
- zb0005--
- var zb0011 int
- var zb0012 bool
- zb0011, zb0012, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if zb0003 > 0 {
+ zb0003--
+ var zb0005 int
+ var zb0006 bool
+ zb0005, zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0011 > MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0011), uint64(MaxReveals))
+ if zb0005 > MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0005), uint64(MaxReveals))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0012 {
+ if zb0006 {
(*z).Reveals = nil
} else if (*z).Reveals == nil {
- (*z).Reveals = make(map[uint64]Reveal, zb0011)
+ (*z).Reveals = make(map[uint64]Reveal, zb0005)
}
- for zb0011 > 0 {
- var zb0003 uint64
- var zb0004 Reveal
- zb0011--
- zb0003, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0005 > 0 {
+ var zb0001 uint64
+ var zb0002 Reveal
+ zb0005--
+ zb0001, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- bts, err = zb0004.UnmarshalMsg(bts)
+ bts, err = zb0002.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0003)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0001)
return
}
- (*z).Reveals[zb0003] = zb0004
+ (*z).Reveals[zb0001] = zb0002
}
}
- if zb0005 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0005)
+ if zb0003 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0003)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -278,11 +221,11 @@ func (z *Cert) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err)
return
}
- if zb0006 {
+ if zb0004 {
(*z) = Cert{}
}
- for zb0005 > 0 {
- zb0005--
+ for zb0003 > 0 {
+ zb0003--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -302,92 +245,50 @@ func (z *Cert) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "S":
- var zb0013 int
- var zb0014 bool
- zb0013, zb0014, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ bts, err = (*z).SigProofs.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0013 > MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0013), uint64(MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs")
- return
- }
- if zb0014 {
- (*z).SigProofs = nil
- } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0013 {
- (*z).SigProofs = ((*z).SigProofs)[:zb0013]
- } else {
- (*z).SigProofs = make([]crypto.Digest, zb0013)
- }
- for zb0001 := range (*z).SigProofs {
- bts, err = (*z).SigProofs[zb0001].UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0001)
- return
- }
- }
case "P":
- var zb0015 int
- var zb0016 bool
- zb0015, zb0016, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ bts, err = (*z).PartProofs.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0015 > MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0015), uint64(MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs")
- return
- }
- if zb0016 {
- (*z).PartProofs = nil
- } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0015 {
- (*z).PartProofs = ((*z).PartProofs)[:zb0015]
- } else {
- (*z).PartProofs = make([]crypto.Digest, zb0015)
- }
- for zb0002 := range (*z).PartProofs {
- bts, err = (*z).PartProofs[zb0002].UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0002)
- return
- }
- }
case "r":
- var zb0017 int
- var zb0018 bool
- zb0017, zb0018, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0007 int
+ var zb0008 bool
+ zb0007, zb0008, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0017 > MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0017), uint64(MaxReveals))
+ if zb0007 > MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0007), uint64(MaxReveals))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0018 {
+ if zb0008 {
(*z).Reveals = nil
} else if (*z).Reveals == nil {
- (*z).Reveals = make(map[uint64]Reveal, zb0017)
+ (*z).Reveals = make(map[uint64]Reveal, zb0007)
}
- for zb0017 > 0 {
- var zb0003 uint64
- var zb0004 Reveal
- zb0017--
- zb0003, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0007 > 0 {
+ var zb0001 uint64
+ var zb0002 Reveal
+ zb0007--
+ zb0001, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- bts, err = zb0004.UnmarshalMsg(bts)
+ bts, err = zb0002.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0003)
+ err = msgp.WrapError(err, "Reveals", zb0001)
return
}
- (*z).Reveals[zb0003] = zb0004
+ (*z).Reveals[zb0001] = zb0002
}
default:
err = msgp.ErrNoField(string(field))
@@ -409,20 +310,12 @@ func (_ *Cert) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Cert) Msgsize() (s int) {
- s = 1 + 2 + (*z).SigCommit.Msgsize() + 2 + msgp.Uint64Size + 2 + msgp.ArrayHeaderSize
- for zb0001 := range (*z).SigProofs {
- s += (*z).SigProofs[zb0001].Msgsize()
- }
- s += 2 + msgp.ArrayHeaderSize
- for zb0002 := range (*z).PartProofs {
- s += (*z).PartProofs[zb0002].Msgsize()
- }
- s += 2 + msgp.MapHeaderSize
+ s = 1 + 2 + (*z).SigCommit.Msgsize() + 2 + msgp.Uint64Size + 2 + (*z).SigProofs.Msgsize() + 2 + (*z).PartProofs.Msgsize() + 2 + msgp.MapHeaderSize
if (*z).Reveals != nil {
- for zb0003, zb0004 := range (*z).Reveals {
- _ = zb0003
- _ = zb0004
- s += 0 + msgp.Uint64Size + zb0004.Msgsize()
+ for zb0001, zb0002 := range (*z).Reveals {
+ _ = zb0001
+ _ = zb0002
+ s += 0 + msgp.Uint64Size + zb0002.Msgsize()
}
}
return
@@ -430,71 +323,44 @@ func (z *Cert) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *Cert) MsgIsZero() bool {
- return ((*z).SigCommit.MsgIsZero()) && ((*z).SignedWeight == 0) && (len((*z).SigProofs) == 0) && (len((*z).PartProofs) == 0) && (len((*z).Reveals) == 0)
+ return ((*z).SigCommit.MsgIsZero()) && ((*z).SignedWeight == 0) && ((*z).SigProofs.MsgIsZero()) && ((*z).PartProofs.MsgIsZero()) && (len((*z).Reveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
func (z *CompactOneTimeSignature) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0001Len := uint32(6)
- var zb0001Mask uint8 /* 8 bits */
- if (*z).OneTimeSignature.PK.MsgIsZero() {
+ zb0001Len := uint32(3)
+ var zb0001Mask uint8 /* 5 bits */
+ if (*z).Signature.ByteSignature.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x4
}
- if (*z).OneTimeSignature.PK1Sig.MsgIsZero() {
+ if (*z).Signature.Proof.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x8
}
- if (*z).OneTimeSignature.PK2.MsgIsZero() {
+ if (*z).Signature.VerifyingKey.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x10
}
- if (*z).OneTimeSignature.PK2Sig.MsgIsZero() {
- zb0001Len--
- zb0001Mask |= 0x20
- }
- if (*z).OneTimeSignature.PKSigOld.MsgIsZero() {
- zb0001Len--
- zb0001Mask |= 0x40
- }
- if (*z).OneTimeSignature.Sig.MsgIsZero() {
- zb0001Len--
- zb0001Mask |= 0x80
- }
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
if zb0001Len != 0 {
if (zb0001Mask & 0x4) == 0 { // if not empty
- // string "p"
- o = append(o, 0xa1, 0x70)
- o = (*z).OneTimeSignature.PK.MarshalMsg(o)
+ // string "bsig"
+ o = append(o, 0xa4, 0x62, 0x73, 0x69, 0x67)
+ o = (*z).Signature.ByteSignature.MarshalMsg(o)
}
if (zb0001Mask & 0x8) == 0 { // if not empty
- // string "p1s"
- o = append(o, 0xa3, 0x70, 0x31, 0x73)
- o = (*z).OneTimeSignature.PK1Sig.MarshalMsg(o)
+ // string "prf"
+ o = append(o, 0xa3, 0x70, 0x72, 0x66)
+ o = (*z).Signature.Proof.MarshalMsg(o)
}
if (zb0001Mask & 0x10) == 0 { // if not empty
- // string "p2"
- o = append(o, 0xa2, 0x70, 0x32)
- o = (*z).OneTimeSignature.PK2.MarshalMsg(o)
- }
- if (zb0001Mask & 0x20) == 0 { // if not empty
- // string "p2s"
- o = append(o, 0xa3, 0x70, 0x32, 0x73)
- o = (*z).OneTimeSignature.PK2Sig.MarshalMsg(o)
- }
- if (zb0001Mask & 0x40) == 0 { // if not empty
- // string "ps"
- o = append(o, 0xa2, 0x70, 0x73)
- o = (*z).OneTimeSignature.PKSigOld.MarshalMsg(o)
- }
- if (zb0001Mask & 0x80) == 0 { // if not empty
- // string "s"
- o = append(o, 0xa1, 0x73)
- o = (*z).OneTimeSignature.Sig.MarshalMsg(o)
+ // string "vkey"
+ o = append(o, 0xa4, 0x76, 0x6b, 0x65, 0x79)
+ o = (*z).Signature.VerifyingKey.MarshalMsg(o)
}
}
return
@@ -520,49 +386,25 @@ func (z *CompactOneTimeSignature) UnmarshalMsg(bts []byte) (o []byte, err error)
}
if zb0001 > 0 {
zb0001--
- bts, err = (*z).OneTimeSignature.Sig.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Sig")
- return
- }
- }
- if zb0001 > 0 {
- zb0001--
- bts, err = (*z).OneTimeSignature.PK.UnmarshalMsg(bts)
+ bts, err = (*z).Signature.ByteSignature.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PK")
+ err = msgp.WrapError(err, "struct-from-array", "ByteSignature")
return
}
}
if zb0001 > 0 {
zb0001--
- bts, err = (*z).OneTimeSignature.PKSigOld.UnmarshalMsg(bts)
+ bts, err = (*z).Signature.Proof.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PKSigOld")
+ err = msgp.WrapError(err, "struct-from-array", "Proof")
return
}
}
if zb0001 > 0 {
zb0001--
- bts, err = (*z).OneTimeSignature.PK2.UnmarshalMsg(bts)
+ bts, err = (*z).Signature.VerifyingKey.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PK2")
- return
- }
- }
- if zb0001 > 0 {
- zb0001--
- bts, err = (*z).OneTimeSignature.PK1Sig.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PK1Sig")
- return
- }
- }
- if zb0001 > 0 {
- zb0001--
- bts, err = (*z).OneTimeSignature.PK2Sig.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PK2Sig")
+ err = msgp.WrapError(err, "struct-from-array", "VerifyingKey")
return
}
}
@@ -589,40 +431,22 @@ func (z *CompactOneTimeSignature) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
switch string(field) {
- case "s":
- bts, err = (*z).OneTimeSignature.Sig.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "Sig")
- return
- }
- case "p":
- bts, err = (*z).OneTimeSignature.PK.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "PK")
- return
- }
- case "ps":
- bts, err = (*z).OneTimeSignature.PKSigOld.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "PKSigOld")
- return
- }
- case "p2":
- bts, err = (*z).OneTimeSignature.PK2.UnmarshalMsg(bts)
+ case "bsig":
+ bts, err = (*z).Signature.ByteSignature.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PK2")
+ err = msgp.WrapError(err, "ByteSignature")
return
}
- case "p1s":
- bts, err = (*z).OneTimeSignature.PK1Sig.UnmarshalMsg(bts)
+ case "prf":
+ bts, err = (*z).Signature.Proof.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PK1Sig")
+ err = msgp.WrapError(err, "Proof")
return
}
- case "p2s":
- bts, err = (*z).OneTimeSignature.PK2Sig.UnmarshalMsg(bts)
+ case "vkey":
+ bts, err = (*z).Signature.VerifyingKey.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PK2Sig")
+ err = msgp.WrapError(err, "VerifyingKey")
return
}
default:
@@ -645,13 +469,13 @@ func (_ *CompactOneTimeSignature) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *CompactOneTimeSignature) Msgsize() (s int) {
- s = 1 + 2 + (*z).OneTimeSignature.Sig.Msgsize() + 2 + (*z).OneTimeSignature.PK.Msgsize() + 3 + (*z).OneTimeSignature.PKSigOld.Msgsize() + 3 + (*z).OneTimeSignature.PK2.Msgsize() + 4 + (*z).OneTimeSignature.PK1Sig.Msgsize() + 4 + (*z).OneTimeSignature.PK2Sig.Msgsize()
+ s = 1 + 5 + (*z).Signature.ByteSignature.Msgsize() + 4 + (*z).Signature.Proof.Msgsize() + 5 + (*z).Signature.VerifyingKey.Msgsize()
return
}
// MsgIsZero returns whether this is a zero value
func (z *CompactOneTimeSignature) MsgIsZero() bool {
- return ((*z).OneTimeSignature.Sig.MsgIsZero()) && ((*z).OneTimeSignature.PK.MsgIsZero()) && ((*z).OneTimeSignature.PKSigOld.MsgIsZero()) && ((*z).OneTimeSignature.PK2.MsgIsZero()) && ((*z).OneTimeSignature.PK1Sig.MsgIsZero()) && ((*z).OneTimeSignature.PK2Sig.MsgIsZero())
+ return ((*z).Signature.ByteSignature.MsgIsZero()) && ((*z).Signature.Proof.MsgIsZero()) && ((*z).Signature.VerifyingKey.MsgIsZero())
}
// MarshalMsg implements msgp.Marshaler
diff --git a/crypto/compactcert/structs.go b/crypto/compactcert/structs.go
index aa74dea3e..0cfee487c 100644
--- a/crypto/compactcert/structs.go
+++ b/crypto/compactcert/structs.go
@@ -18,22 +18,25 @@ package compactcert
import (
"github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklearray"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/protocol"
)
// Params defines common parameters for the verifier and builder.
type Params struct {
- Msg crypto.Hashable // Message to be cerified
- ProvenWeight uint64 // Weight threshold proven by the certificate
- SigRound basics.Round // Ephemeral signature round to expect
- SecKQ uint64 // Security parameter (k+q) from analysis document
+ Msg crypto.Hashable // Message to be cerified
+ ProvenWeight uint64 // Weight threshold proven by the certificate
+ SigRound basics.Round // The round for which the ephemeral key is committed to
+ SecKQ uint64 // Security parameter (k+q) from analysis document
+ CompactCertRounds uint64 // the frequency in which CC are being formed
}
// CompactOneTimeSignature is crypto.OneTimeSignature with omitempty
type CompactOneTimeSignature struct {
_struct struct{} `codec:",omitempty,omitemptyarray"`
- crypto.OneTimeSignature
+ merklekeystore.Signature
}
// A sigslotCommit is a single slot in the sigs array that forms the certificate.
@@ -63,20 +66,14 @@ type Reveal struct {
Part basics.Participant `codec:"p"`
}
-// MaxReveals is a bound on allocation and on numReveals to limit log computation
-const MaxReveals = 1024
-
-// MaxProofDigests is a bound on allocation on number of proofs
-const MaxProofDigests = 20 * MaxReveals
-
// Cert represents a compact certificate.
type Cert struct {
_struct struct{} `codec:",omitempty,omitemptyarray"`
- SigCommit crypto.Digest `codec:"c"`
- SignedWeight uint64 `codec:"w"`
- SigProofs []crypto.Digest `codec:"S,allocbound=MaxProofDigests"`
- PartProofs []crypto.Digest `codec:"P,allocbound=MaxProofDigests"`
+ SigCommit crypto.GenericDigest `codec:"c"`
+ SignedWeight uint64 `codec:"w"`
+ SigProofs merklearray.Proof `codec:"S,allocbound=MaxProofDigests"`
+ PartProofs merklearray.Proof `codec:"P,allocbound=MaxProofDigests"`
// Reveals is a sparse map from the position being revealed
// to the corresponding elements from the sigs and participants
diff --git a/crypto/compactcert/verifier.go b/crypto/compactcert/verifier.go
index 38747d611..985aaf6e0 100644
--- a/crypto/compactcert/verifier.go
+++ b/crypto/compactcert/verifier.go
@@ -21,20 +21,19 @@ import (
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/crypto/merklearray"
- "github.com/algorand/go-algorand/data/basics"
)
// Verifier is used to verify a compact certificate.
type Verifier struct {
Params
- partcom crypto.Digest
+ partcom crypto.GenericDigest
}
// MkVerifier constructs a verifier to check the compact certificate
// on the message specified in p, with partcom specifying the Merkle
// root of the participants that must sign the message.
-func MkVerifier(p Params, partcom crypto.Digest) *Verifier {
+func MkVerifier(p Params, partcom crypto.GenericDigest) *Verifier {
return &Verifier{
Params: p,
partcom: partcom,
@@ -48,26 +47,29 @@ func (v *Verifier) Verify(c *Cert) error {
return fmt.Errorf("cert signed weight %d <= proven weight %d", c.SignedWeight, v.ProvenWeight)
}
- // Verify all of the reveals
- sigs := make(map[uint64]crypto.Digest)
- parts := make(map[uint64]crypto.Digest)
+ sigs := make(map[uint64]crypto.Hashable)
+ parts := make(map[uint64]crypto.Hashable)
for pos, r := range c.Reveals {
- sigs[pos] = crypto.HashObj(r.SigSlot)
- parts[pos] = crypto.HashObj(r.Part)
-
- ephID := basics.OneTimeIDForRound(v.SigRound, r.Part.KeyDilution)
- if !r.Part.PK.Verify(ephID, v.Msg, r.SigSlot.Sig.OneTimeSignature) {
- return fmt.Errorf("signature in reveal pos %d does not verify", pos)
+ sigs[pos] = r.SigSlot
+ parts[pos] = r.Part
+
+ err := r.Part.PK.Verify(
+ uint64(r.Part.FirstValid),
+ uint64(v.SigRound),
+ v.CompactCertRounds,
+ v.Msg,
+ r.SigSlot.Sig.Signature)
+
+ if err != nil {
+ return fmt.Errorf("signature in reveal pos %d does not verify. error is %s", pos, err)
}
}
- err := merklearray.Verify(c.SigCommit, sigs, c.SigProofs)
- if err != nil {
+ if err := merklearray.Verify(crypto.GenericDigest(c.SigCommit[:]), sigs, &c.SigProofs); err != nil {
return err
}
- err = merklearray.Verify(v.partcom, parts, c.PartProofs)
- if err != nil {
+ if err := merklearray.Verify(crypto.GenericDigest(v.partcom[:]), parts, &c.PartProofs); err != nil {
return err
}
@@ -76,8 +78,11 @@ func (v *Verifier) Verify(c *Cert) error {
if err != nil {
return err
}
-
- msgHash := crypto.HashObj(v.Msg)
+ h, err := c.PartProofs.HashFactory.NewHash()
+ if err != nil {
+ return err
+ }
+ msgHash := crypto.GenereicHashObj(h, v.Msg)
for j := uint64(0); j < nr; j++ {
choice := coinChoice{
diff --git a/crypto/curve25519.go b/crypto/curve25519.go
index eede5d337..eef5163fe 100644
--- a/crypto/curve25519.go
+++ b/crypto/curve25519.go
@@ -205,7 +205,7 @@ func GenerateSignatureSecrets(seed Seed) *SignatureSecrets {
// cryptographic secrets.
func (s *SignatureSecrets) Sign(message Hashable) Signature {
cryptoSigSecretsSignTotal.Inc(map[string]string{})
- return s.SignBytes(hashRep(message))
+ return s.SignBytes(HashRep(message))
}
// SignBytes signs a message directly, without first hashing.
@@ -222,7 +222,7 @@ func (s *SignatureSecrets) SignBytes(message []byte) Signature {
//
func (v SignatureVerifier) Verify(message Hashable, sig Signature) bool {
cryptoSigSecretsVerifyTotal.Inc(map[string]string{})
- return ed25519Verify(ed25519PublicKey(v), hashRep(message), ed25519Signature(sig))
+ return ed25519Verify(ed25519PublicKey(v), HashRep(message), ed25519Signature(sig))
}
// VerifyBytes verifies a signature, where the message is not hashed first.
diff --git a/crypto/curve25519_wrapper.go b/crypto/curve25519_wrapper.go
new file mode 100644
index 000000000..def609b22
--- /dev/null
+++ b/crypto/curve25519_wrapper.go
@@ -0,0 +1,82 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+// GenerateEd25519Key is responsible for creating some unknown key
+func GenerateEd25519Key(seed Seed) *Ed25519Key {
+ return &Ed25519Key{
+ Sec: *GenerateSignatureSecrets(seed),
+ }
+}
+
+// Ed25519Key represents an unknown key
+// the struct implements Signer
+type Ed25519Key struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ Sec SignatureSecrets `codec:"sec"`
+}
+
+// Ed25519PublicKey represents an unknown public key
+// the struct implements Verifier
+type Ed25519PublicKey struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ SignatureVerifier `codec:"sigVerifier"`
+}
+
+// Sign - Signs a Hashable message
+func (p *Ed25519Key) Sign(message Hashable) ByteSignature {
+ sig := p.Sec.Sign(message)
+ return sig[:]
+}
+
+// SignBytes - Signs a a slice of bytes
+func (p *Ed25519Key) SignBytes(message []byte) ByteSignature {
+ sig := p.Sec.SignBytes(message)
+ return sig[:]
+}
+
+// GetVerifyingKey outputs a representation of a public key. that implements Verifier
+func (p *Ed25519Key) GetVerifyingKey() *VerifyingKey {
+ return &VerifyingKey{
+ Type: Ed25519Type,
+ Pack: PackedVerifyingKey{Ed25519PublicKey: Ed25519PublicKey{SignatureVerifier: p.Sec.SignatureVerifier}},
+ }
+}
+
+// Verify that a signature match to a specific message
+func (p *Ed25519PublicKey) Verify(message Hashable, sig ByteSignature) error {
+ if !p.SignatureVerifier.Verify(message, byteSigToSignatureType(sig)) {
+ return ErrBadSignature
+ }
+ return nil
+}
+
+// VerifyBytes checks that a signature match to a specific byte message
+func (p *Ed25519PublicKey) VerifyBytes(message []byte, sig ByteSignature) error {
+ if !p.SignatureVerifier.VerifyBytes(message, byteSigToSignatureType(sig)) {
+ return ErrBadSignature
+ }
+ return nil
+}
+
+func byteSigToSignatureType(sig ByteSignature) Signature {
+ var scopy Signature
+ copy(scopy[:], sig)
+ return scopy
+}
diff --git a/crypto/digest.go b/crypto/digest.go
new file mode 100644
index 000000000..86cc12bd9
--- /dev/null
+++ b/crypto/digest.go
@@ -0,0 +1,44 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import "bytes"
+
+// GenericDigest is a digest that implements CustumSizeDigest, and can be used as hash output.
+//msgp:allocbound GenericDigest
+type GenericDigest []byte
+
+// To32Byte is used to change the data into crypto.Digest.
+func (d GenericDigest) To32Byte() [Sha512_256Size]byte {
+ var cpy [Sha512_256Size]byte
+ copy(cpy[:], d)
+ return cpy
+
+}
+
+// ToSlice is used inside the Tree itself when interacting with TreeDigest
+func (d GenericDigest) ToSlice() []byte { return d }
+
+// IsEqual compare two digests
+func (d GenericDigest) IsEqual(other GenericDigest) bool {
+ return bytes.Equal(d, other)
+}
+
+// IsEmpty checks wether the generic digest is an empty one or not
+func (d GenericDigest) IsEmpty() bool {
+ return len(d) == 0
+}
diff --git a/crypto/dillithium.go b/crypto/dillithium.go
new file mode 100644
index 000000000..1bfa5b2ec
--- /dev/null
+++ b/crypto/dillithium.go
@@ -0,0 +1,97 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import cdilithium "github.com/algorand/dilithium/ref"
+
+// Exporting signature, publicKey, secretKey.
+type (
+ //DilithiumPublicKey is the public key
+ //msgp:allocbound DilithiumPublicKey
+ DilithiumPublicKey []byte
+ //DilithiumPrivateKey is the private key
+ //msgp:allocbound DilithiumPrivateKey
+ DilithiumPrivateKey []byte
+ //DilithiumSignature is the exported signature
+ //msgp:allocbound DilithiumSignature
+ DilithiumSignature ByteSignature
+
+ // DPublicKey is a wrapper for cdilithium.DilPublicKey (used for packing)
+ DPublicKey [cdilithium.PublicKeySize]byte //cdilithium.DilPublicKey
+ // DSecretKey is a wrapper for cdilithium.DilPrivateKe (used for packing)
+ DSecretKey [cdilithium.PrivateKeySize]byte //cdilithium.DilPrivateKe
+)
+
+// DilithiumSigner is the implementation of Signer for the Dilithium signature scheme.
+type DilithiumSigner struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ PublicKey DPublicKey `codec:"pk"`
+ SecretKey DSecretKey `codec:"sk"`
+}
+
+// NewDilithiumSigner Generates a dilithium Signer.
+func NewDilithiumSigner() Signer {
+ sk, pk := cdilithium.NewKeys()
+ return &DilithiumSigner{
+ PublicKey: DPublicKey(pk),
+ SecretKey: DSecretKey(sk),
+ }
+}
+
+// Sign receives a message and generates a signature over that message.
+// the size of the signature should conform with cdilithium.SigSize.
+func (d *DilithiumSigner) Sign(message Hashable) ByteSignature {
+ hs := Hash(HashRep(message))
+ return d.SignBytes(hs[:])
+}
+
+// SignBytes receives bytes and signs over them.
+// the size of the signature should conform with cdilithium.SigSize.
+func (d *DilithiumSigner) SignBytes(data []byte) ByteSignature {
+ return (*cdilithium.DilPrivateKey)(&d.SecretKey).SignBytes(data)
+}
+
+// GetVerifyingKey Outputs a verifying key object which is serializable.
+func (d *DilithiumSigner) GetVerifyingKey() *VerifyingKey {
+ return &VerifyingKey{
+ Type: DilithiumType,
+ Pack: PackedVerifyingKey{
+ DilithiumPublicKey: DilithiumVerifier{
+ PublicKey: d.PublicKey,
+ },
+ },
+ }
+}
+
+// DilithiumVerifier implements the type Verifier interface for the dilithium signature scheme.
+type DilithiumVerifier struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ PublicKey DPublicKey `codec:"k"`
+}
+
+// Verify follows dilithium algorithm to verify a signature.
+func (d *DilithiumVerifier) Verify(message Hashable, sig ByteSignature) error {
+ hs := Hash(HashRep(message))
+ return d.VerifyBytes(hs[:], sig)
+}
+
+// VerifyBytes follows dilithium algorithm to verify a signature.
+func (d *DilithiumVerifier) VerifyBytes(data []byte, sig ByteSignature) error {
+ return (*cdilithium.DilPublicKey)(&d.PublicKey).VerifyBytes(data, sig)
+}
diff --git a/crypto/dillithium_test.go b/crypto/dillithium_test.go
new file mode 100644
index 000000000..63deb3b4f
--- /dev/null
+++ b/crypto/dillithium_test.go
@@ -0,0 +1,83 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import (
+ "crypto/sha256"
+ "encoding/binary"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestDilithiumSignAndVerify(t *testing.T) {
+ a := require.New(t)
+ for i := 0; i < 100; i++ {
+ dsigner := NewDilithiumSigner()
+ b := make([]byte, 8)
+ binary.BigEndian.PutUint64(b, uint64(i))
+ bs := sha256.Sum256(b)
+ sig := dsigner.SignBytes(bs[:])
+ //sig := dil2Sign(sk, bs[:])
+ dvf := dsigner.GetVerifyingKey()
+ dverifier, err := dvf.GetVerifier()
+ a.NoError(err)
+ a.NoError(dverifier.VerifyBytes(bs[:], sig))
+ }
+}
+
+func TestDilithiumSignerImplemantation(t *testing.T) {
+ a := require.New(t)
+ dsigner := NewDilithiumSigner()
+
+ sig := dsigner.Sign(TestingHashable{})
+
+ dvf := dsigner.GetVerifyingKey()
+ dverifier, err := dvf.GetVerifier()
+ a.NoError(err)
+ a.NoError(dverifier.Verify(TestingHashable{}, sig))
+ a.Error(dverifier.Verify(TestingHashable{
+ data: []byte{1, 2, 3},
+ }, sig))
+ sig[0]++
+ a.Error(dverifier.Verify(TestingHashable{}, sig))
+
+ bs := sha256.Sum256(make([]byte, 8))
+ sig2 := dsigner.SignBytes(bs[:])
+ a.NoError(dverifier.VerifyBytes(bs[:], sig2))
+
+ bs2 := bs
+ bs2[0]++
+ a.Error(dverifier.VerifyBytes(bs2[:], sig2))
+ sig2[0]++
+ a.Error(dverifier.VerifyBytes(bs[:], sig2))
+
+ // Non-empty hashable:
+ hashableWithData := TestingHashable{
+ data: []byte{1, 2, 3},
+ }
+ sig = dsigner.Sign(hashableWithData)
+ a.NoError(dverifier.Verify(hashableWithData, sig))
+
+ sig = dsigner.Sign(hashableWithData)
+ hashableWithData.data[0]++
+ a.Error(dverifier.Verify(hashableWithData, sig))
+ hashableWithData.data[0]--
+
+ sig[0]++
+ a.Error(dverifier.Verify(hashableWithData, sig))
+}
diff --git a/crypto/hashes.go b/crypto/hashes.go
new file mode 100644
index 000000000..c3b64e86f
--- /dev/null
+++ b/crypto/hashes.go
@@ -0,0 +1,92 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import (
+ "crypto/sha512"
+ "errors"
+ "hash"
+
+ "github.com/algonathan/sumhash"
+ "golang.org/x/crypto/sha3"
+)
+
+var sumhashCompressor sumhash.LookupTable
+
+// TODO: will be removed once the sumhash lib will update.
+func init() {
+ shk := sha3.NewShake256()
+ seed := []byte("Algorand")
+ _, err := shk.Write(seed)
+ if err != nil {
+ panic(err)
+ }
+ mat, err := sumhash.RandomMatrix(shk, 8, 1024)
+ if err != nil {
+ panic(err)
+ }
+ sumhashCompressor = mat.LookupTable()
+}
+
+// HashType enum type for signing algorithms
+type HashType uint64
+
+// types of hashes
+const (
+ Sha512_256 HashType = iota
+ Sumhash
+)
+
+//size of each hash
+const (
+ Sha512_256Size = sha512.Size256
+ SumhashDigestSize = 64
+)
+
+// HashFactory is responsible for generating new hashes accordingly to the type it stores.
+type HashFactory struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+ HashType HashType `codec:"t"`
+}
+
+var errUnknownHash = errors.New("unknown hash type")
+
+// NewHash generates a new hash.Hash to use.
+func (h HashFactory) NewHash() (hash.Hash, error) {
+ switch h.HashType {
+ case Sha512_256:
+ return sha512.New512_256(), nil
+ case Sumhash:
+ return sumhash.New(sumhashCompressor), nil
+ default:
+ return nil, errUnknownHash
+ }
+}
+
+// GenereicHashObj Makes it easier to sum using hash interface and Hashable interface
+func GenereicHashObj(hsh hash.Hash, h Hashable) []byte {
+ rep := HashRep(h)
+ return HashBytes(hsh, rep)
+}
+
+// HashBytes Makes it easier to sum using hash interface.
+func HashBytes(hash hash.Hash, m []byte) []byte {
+ hash.Reset()
+ hash.Write(m)
+ outhash := hash.Sum(nil)
+ return outhash
+}
diff --git a/crypto/hashes_test.go b/crypto/hashes_test.go
new file mode 100644
index 000000000..9fd410eb4
--- /dev/null
+++ b/crypto/hashes_test.go
@@ -0,0 +1,62 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import (
+ "github.com/algorand/go-algorand/test/partitiontest"
+ "math"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestHashFactoryCreatingNewHashes(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ a := require.New(t)
+
+ hfactory := HashFactory{HashType: Sha512_256}
+ h, err := hfactory.NewHash()
+ a.NoError(err)
+ a.NotNil(h)
+ a.Equal(Sha512_256Size, h.Size())
+
+ hfactory = HashFactory{HashType: Sumhash}
+ h, err = hfactory.NewHash()
+ a.NoError(err)
+ a.NotNil(h)
+ a.Equal(SumhashDigestSize, h.Size())
+
+ hfactory = HashFactory{HashType: HashType(math.MaxUint64)}
+ h, err = hfactory.NewHash()
+ a.Error(err)
+ a.Nil(h)
+}
+
+func TestHashSum(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ a := require.New(t)
+
+ hfactory := HashFactory{HashType: Sha512_256}
+ h, err := hfactory.NewHash()
+ a.NoError(err)
+ a.NotNil(h)
+ a.Equal(Sha512_256Size, h.Size())
+
+ dgst := HashObj(TestingHashable{})
+ a.Equal(GenereicHashObj(h, TestingHashable{}), dgst[:])
+
+}
diff --git a/crypto/merklearray/array.go b/crypto/merklearray/array.go
index b8e281a8e..2ceee82bb 100644
--- a/crypto/merklearray/array.go
+++ b/crypto/merklearray/array.go
@@ -16,14 +16,10 @@
package merklearray
-import (
- "github.com/algorand/go-algorand/crypto"
-)
-
// An Array represents a dense array of leaf elements that are
-// combined into a Merkle tree. The GetHash method returns the
-// hash of a particular element in the array.
+// combined into a Merkle tree. The Marshal method returns a byte slice that represents the object
+// and the Tree will use to hash the leaves.
type Array interface {
Length() uint64
- GetHash(pos uint64) (crypto.Digest, error)
+ Marshal(pos uint64) ([]byte, error)
}
diff --git a/crypto/merklearray/layer.go b/crypto/merklearray/layer.go
index 614516e85..3513a6a22 100644
--- a/crypto/merklearray/layer.go
+++ b/crypto/merklearray/layer.go
@@ -17,39 +17,44 @@
package merklearray
import (
+ "hash"
+
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/protocol"
)
-// A layer of the Merkle tree consists of a dense array of hashes at that
+// A Layer of the Merkle tree consists of a dense array of hashes at that
// level of the tree. Hashes beyond the end of the array (e.g., if the
// number of leaves is not an exact power of 2) are implicitly zero.
-type layer []crypto.Digest
+//msgp:allocbound Layer -
+type Layer []crypto.GenericDigest
// A pair represents an internal node in the Merkle tree.
type pair struct {
- l crypto.Digest
- r crypto.Digest
+ l crypto.GenericDigest
+ r crypto.GenericDigest
}
func (p *pair) ToBeHashed() (protocol.HashID, []byte) {
- var buf [2 * crypto.DigestSize]byte
- copy(buf[:crypto.DigestSize], p.l[:])
- copy(buf[crypto.DigestSize:], p.r[:])
+ buf := make([]byte, len(p.l)+len(p.r))
+ copy(buf[:], p.l[:])
+ copy(buf[len(p.l):], p.r[:])
return protocol.MerkleArrayNode, buf[:]
}
-// Hash implements an optimized version of crypto.HashObj(p).
-func (p *pair) Hash() crypto.Digest {
- var buf [len(protocol.MerkleArrayNode) + 2*crypto.DigestSize]byte
- s := buf[:0]
- s = append(s, protocol.MerkleArrayNode...)
- s = append(s, p.l[:]...)
- s = append(s, p.r[:]...)
- return crypto.Hash(s)
+func (p *pair) Marshal() []byte {
+
+ buf := make([]byte, len(p.l)+len(p.r)+len(protocol.MerkleArrayNode))
+ copy(buf[:], protocol.MerkleArrayNode)
+ copy(buf[len(protocol.MerkleArrayNode):], p.l[:])
+ copy(buf[len(protocol.MerkleArrayNode)+len(p.l):], p.r[:])
+
+ return buf
}
-func upWorker(ws *workerState, in layer, out layer) {
+func upWorker(ws *workerState, in Layer, out Layer, h hash.Hash) {
+ defer ws.wg.Done()
+
ws.started()
batchSize := uint64(2)
@@ -65,27 +70,10 @@ func upWorker(ws *workerState, in layer, out layer) {
if i+1 < ws.maxidx {
p.r = in[i+1]
}
- out[i/2] = p.Hash()
+
+ out[i/2] = crypto.GenereicHashObj(h, &p)
}
batchSize += 2
}
-
- ws.done()
-}
-
-// up takes a layer representing some level in the tree,
-// and returns the next-higher level in the tree,
-// represented as a layer.
-func (l layer) up() layer {
- n := len(l)
- res := make(layer, (uint64(n)+1)/2)
-
- ws := newWorkerState(uint64(n))
- for ws.nextWorker() {
- go upWorker(ws, l, res)
- }
- ws.wait()
-
- return res
}
diff --git a/crypto/merklearray/layer_test.go b/crypto/merklearray/layer_test.go
index 96418757f..950aa9960 100644
--- a/crypto/merklearray/layer_test.go
+++ b/crypto/merklearray/layer_test.go
@@ -21,15 +21,16 @@ import (
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/stretchr/testify/require"
)
func TestLayerHash(t *testing.T) {
partitiontest.PartitionTest(t)
- var p pair
+ var p = pair{make([]byte, crypto.Sha512_256Size), make([]byte, crypto.Sha512_256Size)}
crypto.RandBytes(p.l[:])
crypto.RandBytes(p.r[:])
- if crypto.HashObj(&p) != p.Hash() {
- t.Error("hash mismatch")
- }
+ hsh, _ := crypto.HashFactory{HashType: crypto.Sha512_256}.NewHash()
+
+ require.Equal(t, crypto.GenereicHashObj(hsh, &p), crypto.HashBytes(hsh, p.Marshal()))
}
diff --git a/crypto/merklearray/merkle.go b/crypto/merklearray/merkle.go
index 06be1bdac..3d177d6b3 100644
--- a/crypto/merklearray/merkle.go
+++ b/crypto/merklearray/merkle.go
@@ -17,7 +17,9 @@
package merklearray
import (
+ "bytes"
"fmt"
+ "hash"
"sort"
"github.com/algorand/go-algorand/crypto"
@@ -26,54 +28,72 @@ import (
// Tree is a Merkle tree, represented by layers of nodes (hashes) in the tree
// at each height.
type Tree struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
// Level 0 is the leaves.
- levels []layer
+ Levels []Layer `codec:"lvls,allocbound=-"`
+ Hash crypto.HashFactory `codec:"hsh"`
}
-func (tree *Tree) topLayer() layer {
- return tree.levels[len(tree.levels)-1]
+// Proof contains the merkle path, along with the hash factory that should be used.
+type Proof struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ Path []crypto.GenericDigest `codec:"pth,allocbound=-"`
+ HashFactory crypto.HashFactory `codec:"hsh"`
}
-func buildWorker(ws *workerState, array Array, leaves layer, errs chan error) {
+func (tree *Tree) topLayer() Layer {
+ return tree.Levels[len(tree.Levels)-1]
+}
+
+type errorChannel chan error
+
+func (ch errorChannel) nonBlockingSend(e error) {
+ select {
+ case ch <- e:
+ default:
+ }
+}
+
+func buildWorker(ws *workerState, array Array, leaves Layer, h crypto.HashFactory, errs errorChannel) {
+ defer ws.wg.Done()
+
ws.started()
batchSize := uint64(1)
-
+ hash, err := h.NewHash()
+ if err != nil {
+ errs.nonBlockingSend(err)
+ return
+ }
for {
off := ws.next(batchSize)
if off >= ws.maxidx {
- goto done
+ return
}
for i := off; i < off+batchSize && i < ws.maxidx; i++ {
- hash, err := array.GetHash(i)
+ m, err := array.Marshal(i)
if err != nil {
- select {
- case errs <- err:
- default:
- }
-
- goto done
+ errs.nonBlockingSend(err)
+ return
}
-
- leaves[i] = hash
+ leaves[i] = crypto.HashBytes(hash, m)
}
batchSize++
}
-
-done:
- ws.done()
}
// Build constructs a Merkle tree given an array.
-func Build(array Array) (*Tree, error) {
+func Build(array Array, factory crypto.HashFactory) (*Tree, error) {
arraylen := array.Length()
- leaves := make(layer, arraylen)
+ leaves := make(Layer, arraylen)
errs := make(chan error, 1)
ws := newWorkerState(arraylen)
for ws.nextWorker() {
- go buildWorker(ws, array, leaves, errs)
+ go buildWorker(ws, array, leaves, factory, errs)
}
ws.wait()
@@ -83,25 +103,30 @@ func Build(array Array) (*Tree, error) {
default:
}
- tree := &Tree{}
-
- if arraylen > 0 {
- tree.levels = []layer{leaves}
-
- for len(tree.topLayer()) > 1 {
- tree.levels = append(tree.levels, tree.topLayer().up())
- }
+ tree := &Tree{
+ Levels: nil,
+ Hash: factory,
}
+ tree.buildLayers(leaves)
return tree, nil
}
+func (tree *Tree) buildLayers(leaves Layer) {
+ if len(leaves) == 0 {
+ return
+ }
+ tree.Levels = []Layer{leaves}
+ for len(tree.topLayer()) > 1 {
+ tree.buildNextLayer()
+ }
+}
+
// Root returns the root hash of the tree.
-func (tree *Tree) Root() crypto.Digest {
+func (tree *Tree) Root() crypto.GenericDigest {
// Special case: commitment to zero-length array
- if len(tree.levels) == 0 {
- var zero crypto.Digest
- return zero
+ if len(tree.Levels) == 0 {
+ return crypto.GenericDigest{}
}
return tree.topLayer()[0]
@@ -111,13 +136,15 @@ const validateProof = false
// Prove constructs a proof for some set of positions in the array that was
// used to construct the tree.
-func (tree *Tree) Prove(idxs []uint64) ([]crypto.Digest, error) {
+func (tree *Tree) Prove(idxs []uint64) (*Proof, error) {
if len(idxs) == 0 {
- return nil, nil
+ return &Proof{
+ HashFactory: tree.Hash,
+ }, nil
}
// Special case: commitment to zero-length array
- if len(tree.levels) == 0 {
+ if len(tree.Levels) == 0 {
return nil, fmt.Errorf("proving in zero-length commitment")
}
@@ -125,8 +152,8 @@ func (tree *Tree) Prove(idxs []uint64) ([]crypto.Digest, error) {
pl := make(partialLayer, 0, len(idxs))
for _, pos := range idxs {
- if pos >= uint64(len(tree.levels[0])) {
- return nil, fmt.Errorf("pos %d larger than leaf count %d", pos, len(tree.levels[0]))
+ if pos >= uint64(len(tree.Levels[0])) {
+ return nil, fmt.Errorf("pos %d larger than leaf count %d", pos, len(tree.Levels[0]))
}
// Discard duplicates
@@ -136,17 +163,20 @@ func (tree *Tree) Prove(idxs []uint64) ([]crypto.Digest, error) {
pl = append(pl, layerItem{
pos: pos,
- hash: tree.levels[0][pos],
+ hash: tree.Levels[0][pos],
})
}
s := &siblings{
tree: tree,
}
-
- for l := uint64(0); l < uint64(len(tree.levels)-1); l++ {
+ hs, err := tree.Hash.NewHash()
+ if err != nil {
+ return nil, err
+ }
+ for l := uint64(0); l < uint64(len(tree.Levels)-1); l++ {
var err error
- pl, err = pl.up(s, l, validateProof)
+ pl, err = pl.up(s, l, validateProof, hs)
if err != nil {
return nil, err
}
@@ -154,61 +184,118 @@ func (tree *Tree) Prove(idxs []uint64) ([]crypto.Digest, error) {
// Confirm that we got the same root hash
if len(pl) != 1 {
- return nil, fmt.Errorf("internal error: partial layer produced %d hashes", len(pl))
+ return nil, fmt.Errorf("internal error: partial Layer produced %d hashes", len(pl))
}
if validateProof {
- computedroot := pl[0]
- if computedroot.pos != 0 || computedroot.hash != tree.topLayer()[0] {
- return nil, fmt.Errorf("internal error: root mismatch during proof")
+ if err := inspectRoot(tree.topLayer()[0], pl); err != nil {
+ return nil, err
}
}
- return s.hints, nil
+ return &Proof{
+ Path: s.hints,
+ HashFactory: tree.Hash,
+ }, nil
+}
+
+func (tree *Tree) buildNextLayer() {
+ l := tree.topLayer()
+ n := len(l)
+ newLayer := make(Layer, (uint64(n)+1)/2)
+
+ ws := newWorkerState(uint64(n))
+ for ws.nextWorker() {
+ // no need to inspect error here -
+ // the factory should've been used to generate hash func in the first layer build
+ h, _ := tree.Hash.NewHash()
+ go upWorker(ws, l, newLayer, h)
+ }
+ ws.wait()
+ tree.Levels = append(tree.Levels, newLayer)
+}
+
+func hashLeafs(elems map[uint64]crypto.Hashable, hash hash.Hash) (map[uint64]crypto.GenericDigest, error) {
+
+ hashedLeafs := make(map[uint64]crypto.GenericDigest)
+ for i, element := range elems {
+ hashedLeafs[i] = crypto.GenereicHashObj(hash, element)
+ }
+
+ return hashedLeafs, nil
}
// Verify ensures that the positions in elems correspond to the respective hashes
// in a tree with the given root hash. The proof is expected to be the proof
// returned by Prove().
-func Verify(root crypto.Digest, elems map[uint64]crypto.Digest, proof []crypto.Digest) error {
+func Verify(root crypto.GenericDigest, elems map[uint64]crypto.Hashable, proof *Proof) error {
+
+ if proof == nil {
+ return fmt.Errorf("proof should not be nil")
+ }
+
if len(elems) == 0 {
- if len(proof) != 0 {
+ if len(proof.Path) != 0 {
return fmt.Errorf("non-empty proof for empty set of elements")
}
-
return nil
}
- pl := make(partialLayer, 0, len(elems))
- for pos, elem := range elems {
- pl = append(pl, layerItem{
- pos: pos,
- hash: elem,
- })
+ hash, err := proof.HashFactory.NewHash()
+ if err != nil {
+ return err
}
- sort.Slice(pl, func(i, j int) bool { return pl[i].pos < pl[j].pos })
+ hashedLeafs, err := hashLeafs(elems, hash)
+ if err != nil {
+ return err
+ }
+
+ pl := buildPartialLayer(hashedLeafs)
+ return verifyPath(root, proof, pl)
+}
+
+func verifyPath(root crypto.GenericDigest, proof *Proof, pl partialLayer) error {
+ hints := proof.Path
+ hsh, err := proof.HashFactory.NewHash()
+ if err != nil {
+ return err
+ }
s := &siblings{
- hints: proof,
+ hints: hints,
}
for l := uint64(0); len(s.hints) > 0 || len(pl) > 1; l++ {
- var err error
- pl, err = pl.up(s, l, true)
- if err != nil {
+ if pl, err = pl.up(s, l, true, hsh); err != nil {
return err
}
if l > 64 {
- return fmt.Errorf("Verify exceeded 64 levels, more than 2^64 leaves not supported")
+ return fmt.Errorf("Verify exceeded 64 Levels, more than 2^64 leaves not supported")
}
}
+ return inspectRoot(root, pl)
+}
+
+func buildPartialLayer(elems map[uint64]crypto.GenericDigest) partialLayer {
+ pl := make(partialLayer, 0, len(elems))
+ for pos, elem := range elems {
+ pl = append(pl, layerItem{
+ pos: pos,
+ hash: elem.ToSlice(),
+ })
+ }
+
+ sort.Slice(pl, func(i, j int) bool { return pl[i].pos < pl[j].pos })
+ return pl
+}
+
+func inspectRoot(root crypto.GenericDigest, pl partialLayer) error {
computedroot := pl[0]
- if computedroot.pos != 0 || computedroot.hash != root {
+ if computedroot.pos != 0 || !bytes.Equal(computedroot.hash, root) {
return fmt.Errorf("root mismatch")
}
-
return nil
}
diff --git a/crypto/merklearray/merkle_test.go b/crypto/merklearray/merkle_test.go
index 765ce6190..78d59c1ed 100644
--- a/crypto/merklearray/merkle_test.go
+++ b/crypto/merklearray/merkle_test.go
@@ -23,6 +23,7 @@ import (
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/protocol"
"github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/stretchr/testify/require"
)
type TestMessage string
@@ -48,13 +49,17 @@ type TestArray []TestData
func (a TestArray) Length() uint64 {
return uint64(len(a))
}
+func hashRep(h crypto.Hashable) []byte {
+ hashid, data := h.ToBeHashed()
+ return append([]byte(hashid), data...)
+}
-func (a TestArray) GetHash(pos uint64) (crypto.Digest, error) {
+func (a TestArray) Marshal(pos uint64) ([]byte, error) {
if pos >= uint64(len(a)) {
- return crypto.Digest{}, fmt.Errorf("pos %d larger than length %d", pos, len(a))
+ return nil, fmt.Errorf("pos %d larger than length %d", pos, len(a))
}
- return crypto.HashObj(a[pos]), nil
+ return hashRep(a[pos]), nil
}
type TestRepeatingArray struct {
@@ -66,108 +71,174 @@ func (a TestRepeatingArray) Length() uint64 {
return a.count
}
-func (a TestRepeatingArray) GetHash(pos uint64) (crypto.Digest, error) {
+func (a TestRepeatingArray) Marshal(pos uint64) ([]byte, error) {
if pos >= a.count {
- return crypto.Digest{}, fmt.Errorf("pos %d larger than length %d", pos, a.count)
+ return nil, fmt.Errorf("pos %d larger than length %d", pos, a.count)
}
- return crypto.HashObj(a.item), nil
+ return hashRep(a.item), nil
}
func TestMerkle(t *testing.T) {
partitiontest.PartitionTest(t)
+ for i := uint64(0); i < 1024; i++ {
+ testMerkle(t, crypto.Sha512_256, i)
+ }
+
+ if !testing.Short() {
+ for i := uint64(0); i < 10; i++ {
+ testMerkle(t, crypto.Sumhash, i)
+ }
+ }
+
+}
+
+func testMerkle(t *testing.T, hashtype crypto.HashType, size uint64) {
var junk TestData
crypto.RandBytes(junk[:])
- for sz := uint64(0); sz < 1024; sz++ {
- a := make(TestArray, sz)
- for i := uint64(0); i < sz; i++ {
- crypto.RandBytes(a[i][:])
- }
+ a := make(TestArray, size)
+ for i := uint64(0); i < size; i++ {
+ crypto.RandBytes(a[i][:])
+ }
- tree, err := Build(a)
- if err != nil {
- t.Error(err)
- }
+ tree, err := Build(a, crypto.HashFactory{HashType: hashtype})
+ require.NoError(t, err)
- root := tree.Root()
+ root := tree.Root()
- var allpos []uint64
- allmap := make(map[uint64]crypto.Digest)
+ var allpos []uint64
+ allmap := make(map[uint64]crypto.Hashable)
- for i := uint64(0); i < sz; i++ {
- proof, err := tree.Prove([]uint64{i})
- if err != nil {
- t.Error(err)
- }
+ for i := uint64(0); i < size; i++ {
+ proof, err := tree.Prove([]uint64{i})
+ require.NoError(t, err)
- err = Verify(root, map[uint64]crypto.Digest{i: crypto.HashObj(a[i])}, proof)
- if err != nil {
- t.Error(err)
- }
+ err = Verify(root, map[uint64]crypto.Hashable{i: a[i]}, proof)
+ require.NoError(t, err)
- err = Verify(root, map[uint64]crypto.Digest{i: crypto.HashObj(junk)}, proof)
- if err == nil {
- t.Errorf("no error when verifying junk")
- }
+ err = Verify(root, map[uint64]crypto.Hashable{i: junk}, proof)
+ require.Error(t, err, "no error when verifying junk")
- allpos = append(allpos, i)
- allmap[i] = crypto.HashObj(a[i])
- }
+ allpos = append(allpos, i)
+ allmap[i] = a[i]
+ }
- proof, err := tree.Prove(allpos)
- if err != nil {
- t.Error(err)
- }
+ proof, err := tree.Prove(allpos)
+ require.NoError(t, err)
- err = Verify(root, allmap, proof)
- if err != nil {
- t.Error(err)
- }
+ err = Verify(root, allmap, proof)
+ require.NoError(t, err)
- err = Verify(root, map[uint64]crypto.Digest{0: crypto.HashObj(junk)}, proof)
- if err == nil {
- t.Errorf("no error when verifying junk batch")
- }
+ err = Verify(root, map[uint64]crypto.Hashable{0: junk}, proof)
+ require.Error(t, err, "no error when verifying junk batch")
- err = Verify(root, map[uint64]crypto.Digest{0: crypto.HashObj(junk)}, nil)
- if err == nil {
- t.Errorf("no error when verifying junk batch")
- }
+ err = Verify(root, map[uint64]crypto.Hashable{0: junk}, nil)
+ require.Error(t, err, "no error when verifying junk batch")
- _, err = tree.Prove([]uint64{sz})
- if err == nil {
- t.Errorf("no error when proving past the end")
- }
+ _, err = tree.Prove([]uint64{size})
+ require.Error(t, err, "no error when proving past the end")
- err = Verify(root, map[uint64]crypto.Digest{sz: crypto.HashObj(junk)}, nil)
- if err == nil {
- t.Errorf("no error when verifying past the end")
- }
+ err = Verify(root, map[uint64]crypto.Hashable{size: junk}, nil)
+ require.Error(t, err, "no error when verifying past the end")
- if sz > 0 {
- var somepos []uint64
- somemap := make(map[uint64]crypto.Digest)
- for i := 0; i < 10; i++ {
- pos := crypto.RandUint64() % sz
- somepos = append(somepos, pos)
- somemap[pos] = crypto.HashObj(a[pos])
- }
-
- proof, err = tree.Prove(somepos)
- if err != nil {
- t.Error(err)
- }
-
- err = Verify(root, somemap, proof)
- if err != nil {
- t.Error(err)
- }
+ if size > 0 {
+ var somepos []uint64
+ somemap := make(map[uint64]crypto.Hashable)
+ for i := 0; i < 10; i++ {
+ pos := crypto.RandUint64() % size
+ somepos = append(somepos, pos)
+ somemap[pos] = a[pos]
}
+
+ proof, err = tree.Prove(somepos)
+ require.NoError(t, err)
+
+ err = Verify(root, somemap, proof)
+ require.NoError(t, err)
}
}
+func TestEmptyProveStructure(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+ size := uint64(10)
+ arr := make(TestArray, size)
+ for i := uint64(0); i < size; i++ {
+ crypto.RandBytes(arr[i][:])
+ }
+
+ tree, err := Build(arr, crypto.HashFactory{HashType: crypto.Sha512_256})
+ a.NoError(err)
+
+ prf, err := tree.Prove(nil)
+ a.NoError(err)
+ a.NotNil(prf)
+ a.Nil(prf.Path)
+ a.Equal(prf.HashFactory, crypto.HashFactory{HashType: crypto.Sha512_256})
+}
+
+type nonmarshalable []int
+
+func (n nonmarshalable) Length() uint64 {
+ return uint64(len(n))
+}
+
+func (n nonmarshalable) Marshal(pos uint64) ([]byte, error) {
+ return nil, fmt.Errorf("can't be marshaled")
+}
+
+func TestErrorInMarshal(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := nonmarshalable{1}
+ _, err := Build(&a, crypto.HashFactory{})
+ require.Error(t, err)
+}
+
+func TestVerifyWithNoElements(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+ size := uint64(10)
+ arr := make(TestArray, size)
+ for i := uint64(0); i < size; i++ {
+ crypto.RandBytes(arr[i][:])
+ }
+ tree, err := Build(arr, crypto.HashFactory{HashType: crypto.Sha512_256})
+ a.NoError(err)
+
+ p, err := tree.Prove([]uint64{1})
+ a.NoError(err)
+ err = Verify(tree.Root(), map[uint64]crypto.Hashable{}, p)
+ require.Error(t, err)
+
+ err = Verify(tree.Root(), map[uint64]crypto.Hashable{}, nil)
+ require.Error(t, err)
+
+ err = Verify(tree.Root(), map[uint64]crypto.Hashable{}, &Proof{HashFactory: crypto.HashFactory{HashType: crypto.Sha512_256}})
+ require.NoError(t, err)
+}
+
+func TestEmptyTree(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+
+ arr := make(TestArray, 0)
+ tree, err := Build(arr, crypto.HashFactory{HashType: crypto.Sha512_256})
+ a.NoError(err)
+ a.Len(tree.Levels, 0)
+
+ arr = make(TestArray, 1)
+ tree, err = Build(arr, crypto.HashFactory{HashType: crypto.Sha512_256})
+ a.NoError(err)
+ a.Len(tree.Levels, 1)
+ a.Equal(tree.Root().ToSlice(), tree.Levels[0][0].ToSlice())
+}
+
func BenchmarkMerkleCommit(b *testing.B) {
for sz := 10; sz <= 100000; sz *= 100 {
msg := make(TestBuf, sz)
@@ -180,7 +251,7 @@ func BenchmarkMerkleCommit(b *testing.B) {
b.Run(fmt.Sprintf("Item%d/Count%d", sz, cnt), func(b *testing.B) {
for i := 0; i < b.N; i++ {
- tree, err := Build(a)
+ tree, err := Build(a, crypto.HashFactory{HashType: crypto.Sha512_256})
if err != nil {
b.Error(err)
}
@@ -198,7 +269,7 @@ func BenchmarkMerkleProve1M(b *testing.B) {
a.item = msg
a.count = 1024 * 1024
- tree, err := Build(a)
+ tree, err := Build(a, crypto.HashFactory{HashType: crypto.Sha512_256})
if err != nil {
b.Error(err)
}
@@ -220,13 +291,13 @@ func BenchmarkMerkleVerify1M(b *testing.B) {
a.item = msg
a.count = 1024 * 1024
- tree, err := Build(a)
+ tree, err := Build(a, crypto.HashFactory{HashType: crypto.Sha512_256})
if err != nil {
b.Error(err)
}
root := tree.Root()
- proofs := make([][]crypto.Digest, a.count)
+ proofs := make([]*Proof, a.count)
for i := uint64(0); i < a.count; i++ {
proofs[i], err = tree.Prove([]uint64{i})
if err != nil {
@@ -237,7 +308,7 @@ func BenchmarkMerkleVerify1M(b *testing.B) {
b.ResetTimer()
for i := uint64(0); i < uint64(b.N); i++ {
- err := Verify(root, map[uint64]crypto.Digest{i % a.count: crypto.HashObj(msg)}, proofs[i])
+ err := Verify(root, map[uint64]crypto.Hashable{i % a.count: msg}, proofs[i])
if err != nil {
b.Error(err)
}
diff --git a/crypto/merklearray/msgp_gen.go b/crypto/merklearray/msgp_gen.go
new file mode 100644
index 000000000..34d8ce840
--- /dev/null
+++ b/crypto/merklearray/msgp_gen.go
@@ -0,0 +1,488 @@
+package merklearray
+
+// Code generated by github.com/algorand/msgp DO NOT EDIT.
+
+import (
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/msgp/msgp"
+)
+
+// The following msgp objects are implemented in this file:
+// Layer
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// Proof
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Tree
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+
+// MarshalMsg implements msgp.Marshaler
+func (z Layer) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ if z == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len(z)))
+ }
+ for za0001 := range z {
+ o = z[za0001].MarshalMsg(o)
+ }
+ return
+}
+
+func (_ Layer) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(Layer)
+ if !ok {
+ _, ok = (z).(*Layer)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Layer) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = nil
+ } else if (*z) != nil && cap((*z)) >= zb0002 {
+ (*z) = (*z)[:zb0002]
+ } else {
+ (*z) = make(Layer, zb0002)
+ }
+ for zb0001 := range *z {
+ bts, err = (*z)[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, zb0001)
+ return
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Layer) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Layer)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z Layer) Msgsize() (s int) {
+ s = msgp.ArrayHeaderSize
+ for za0001 := range z {
+ s += z[za0001].Msgsize()
+ }
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z Layer) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Proof) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(2)
+ var zb0002Mask uint8 /* 3 bits */
+ if (*z).HashFactory.MsgIsZero() {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ if len((*z).Path) == 0 {
+ zb0002Len--
+ zb0002Mask |= 0x4
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "hsh"
+ o = append(o, 0xa3, 0x68, 0x73, 0x68)
+ o = (*z).HashFactory.MarshalMsg(o)
+ }
+ if (zb0002Mask & 0x4) == 0 { // if not empty
+ // string "pth"
+ o = append(o, 0xa3, 0x70, 0x74, 0x68)
+ if (*z).Path == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).Path)))
+ }
+ for zb0001 := range (*z).Path {
+ o = (*z).Path[zb0001].MarshalMsg(o)
+ }
+ }
+ }
+ return
+}
+
+func (_ *Proof) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Proof)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Proof) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ var zb0004 int
+ var zb0005 bool
+ zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Path")
+ return
+ }
+ if zb0005 {
+ (*z).Path = nil
+ } else if (*z).Path != nil && cap((*z).Path) >= zb0004 {
+ (*z).Path = ((*z).Path)[:zb0004]
+ } else {
+ (*z).Path = make([]crypto.GenericDigest, zb0004)
+ }
+ for zb0001 := range (*z).Path {
+ bts, err = (*z).Path[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Path", zb0001)
+ return
+ }
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ bts, err = (*z).HashFactory.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HashFactory")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = Proof{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "pth":
+ var zb0006 int
+ var zb0007 bool
+ zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Path")
+ return
+ }
+ if zb0007 {
+ (*z).Path = nil
+ } else if (*z).Path != nil && cap((*z).Path) >= zb0006 {
+ (*z).Path = ((*z).Path)[:zb0006]
+ } else {
+ (*z).Path = make([]crypto.GenericDigest, zb0006)
+ }
+ for zb0001 := range (*z).Path {
+ bts, err = (*z).Path[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Path", zb0001)
+ return
+ }
+ }
+ case "hsh":
+ bts, err = (*z).HashFactory.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HashFactory")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Proof) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Proof)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Proof) Msgsize() (s int) {
+ s = 1 + 4 + msgp.ArrayHeaderSize
+ for zb0001 := range (*z).Path {
+ s += (*z).Path[zb0001].Msgsize()
+ }
+ s += 4 + (*z).HashFactory.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Proof) MsgIsZero() bool {
+ return (len((*z).Path) == 0) && ((*z).HashFactory.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Tree) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0003Len := uint32(2)
+ var zb0003Mask uint8 /* 3 bits */
+ if (*z).Hash.MsgIsZero() {
+ zb0003Len--
+ zb0003Mask |= 0x2
+ }
+ if len((*z).Levels) == 0 {
+ zb0003Len--
+ zb0003Mask |= 0x4
+ }
+ // variable map header, size zb0003Len
+ o = append(o, 0x80|uint8(zb0003Len))
+ if zb0003Len != 0 {
+ if (zb0003Mask & 0x2) == 0 { // if not empty
+ // string "hsh"
+ o = append(o, 0xa3, 0x68, 0x73, 0x68)
+ o = (*z).Hash.MarshalMsg(o)
+ }
+ if (zb0003Mask & 0x4) == 0 { // if not empty
+ // string "lvls"
+ o = append(o, 0xa4, 0x6c, 0x76, 0x6c, 0x73)
+ if (*z).Levels == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).Levels)))
+ }
+ for zb0001 := range (*z).Levels {
+ if (*z).Levels[zb0001] == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).Levels[zb0001])))
+ }
+ for zb0002 := range (*z).Levels[zb0001] {
+ o = (*z).Levels[zb0001][zb0002].MarshalMsg(o)
+ }
+ }
+ }
+ }
+ return
+}
+
+func (_ *Tree) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Tree)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Tree) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0003 int
+ var zb0004 bool
+ zb0003, zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0003, zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 > 0 {
+ zb0003--
+ var zb0005 int
+ var zb0006 bool
+ zb0005, zb0006, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Levels")
+ return
+ }
+ if zb0006 {
+ (*z).Levels = nil
+ } else if (*z).Levels != nil && cap((*z).Levels) >= zb0005 {
+ (*z).Levels = ((*z).Levels)[:zb0005]
+ } else {
+ (*z).Levels = make([]Layer, zb0005)
+ }
+ for zb0001 := range (*z).Levels {
+ var zb0007 int
+ var zb0008 bool
+ zb0007, zb0008, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Levels", zb0001)
+ return
+ }
+ if zb0008 {
+ (*z).Levels[zb0001] = nil
+ } else if (*z).Levels[zb0001] != nil && cap((*z).Levels[zb0001]) >= zb0007 {
+ (*z).Levels[zb0001] = ((*z).Levels[zb0001])[:zb0007]
+ } else {
+ (*z).Levels[zb0001] = make(Layer, zb0007)
+ }
+ for zb0002 := range (*z).Levels[zb0001] {
+ bts, err = (*z).Levels[zb0001][zb0002].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Levels", zb0001, zb0002)
+ return
+ }
+ }
+ }
+ }
+ if zb0003 > 0 {
+ zb0003--
+ bts, err = (*z).Hash.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Hash")
+ return
+ }
+ }
+ if zb0003 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0003)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0004 {
+ (*z) = Tree{}
+ }
+ for zb0003 > 0 {
+ zb0003--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "lvls":
+ var zb0009 int
+ var zb0010 bool
+ zb0009, zb0010, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Levels")
+ return
+ }
+ if zb0010 {
+ (*z).Levels = nil
+ } else if (*z).Levels != nil && cap((*z).Levels) >= zb0009 {
+ (*z).Levels = ((*z).Levels)[:zb0009]
+ } else {
+ (*z).Levels = make([]Layer, zb0009)
+ }
+ for zb0001 := range (*z).Levels {
+ var zb0011 int
+ var zb0012 bool
+ zb0011, zb0012, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Levels", zb0001)
+ return
+ }
+ if zb0012 {
+ (*z).Levels[zb0001] = nil
+ } else if (*z).Levels[zb0001] != nil && cap((*z).Levels[zb0001]) >= zb0011 {
+ (*z).Levels[zb0001] = ((*z).Levels[zb0001])[:zb0011]
+ } else {
+ (*z).Levels[zb0001] = make(Layer, zb0011)
+ }
+ for zb0002 := range (*z).Levels[zb0001] {
+ bts, err = (*z).Levels[zb0001][zb0002].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Levels", zb0001, zb0002)
+ return
+ }
+ }
+ }
+ case "hsh":
+ bts, err = (*z).Hash.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Hash")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Tree) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Tree)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Tree) Msgsize() (s int) {
+ s = 1 + 5 + msgp.ArrayHeaderSize
+ for zb0001 := range (*z).Levels {
+ s += msgp.ArrayHeaderSize
+ for zb0002 := range (*z).Levels[zb0001] {
+ s += (*z).Levels[zb0001][zb0002].Msgsize()
+ }
+ }
+ s += 4 + (*z).Hash.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Tree) MsgIsZero() bool {
+ return (len((*z).Levels) == 0) && ((*z).Hash.MsgIsZero())
+}
diff --git a/crypto/merklearray/msgp_gen_test.go b/crypto/merklearray/msgp_gen_test.go
new file mode 100644
index 000000000..6313cb256
--- /dev/null
+++ b/crypto/merklearray/msgp_gen_test.go
@@ -0,0 +1,193 @@
+// +build !skip_msgp_testing
+
+package merklearray
+
+// Code generated by github.com/algorand/msgp DO NOT EDIT.
+
+import (
+ "testing"
+
+ "github.com/algorand/go-algorand/protocol"
+ "github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/algorand/msgp/msgp"
+)
+
+func TestMarshalUnmarshalLayer(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Layer{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingLayer(t *testing.T) {
+ protocol.RunEncodingTest(t, &Layer{})
+}
+
+func BenchmarkMarshalMsgLayer(b *testing.B) {
+ v := Layer{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgLayer(b *testing.B) {
+ v := Layer{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalLayer(b *testing.B) {
+ v := Layer{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalProof(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Proof{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingProof(t *testing.T) {
+ protocol.RunEncodingTest(t, &Proof{})
+}
+
+func BenchmarkMarshalMsgProof(b *testing.B) {
+ v := Proof{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgProof(b *testing.B) {
+ v := Proof{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalProof(b *testing.B) {
+ v := Proof{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalTree(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Tree{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingTree(t *testing.T) {
+ protocol.RunEncodingTest(t, &Tree{})
+}
+
+func BenchmarkMarshalMsgTree(b *testing.B) {
+ v := Tree{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgTree(b *testing.B) {
+ v := Tree{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalTree(b *testing.B) {
+ v := Tree{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
diff --git a/crypto/merklearray/partial.go b/crypto/merklearray/partial.go
index d40d6f1d2..f060e296b 100644
--- a/crypto/merklearray/partial.go
+++ b/crypto/merklearray/partial.go
@@ -18,6 +18,7 @@ package merklearray
import (
"fmt"
+ "hash"
"github.com/algorand/go-algorand/crypto"
)
@@ -28,15 +29,15 @@ import (
// or use the set of sibling hints, if tree is nil.
type siblings struct {
tree *Tree
- hints []crypto.Digest
+ hints []crypto.GenericDigest
}
// get returns the sibling from tree level l (0 being the leaves)
// position i.
-func (s *siblings) get(l uint64, i uint64) (res crypto.Digest, err error) {
+func (s *siblings) get(l uint64, i uint64) (res crypto.GenericDigest, err error) {
if s.tree == nil {
if len(s.hints) > 0 {
- res = s.hints[0]
+ res = s.hints[0].ToSlice()
s.hints = s.hints[1:]
return
}
@@ -45,31 +46,32 @@ func (s *siblings) get(l uint64, i uint64) (res crypto.Digest, err error) {
return
}
- if l >= uint64(len(s.tree.levels)) {
- err = fmt.Errorf("level %d beyond tree height %d", l, len(s.tree.levels))
+ if l >= uint64(len(s.tree.Levels)) {
+ err = fmt.Errorf("level %d beyond tree height %d", l, len(s.tree.Levels))
return
}
- if i < uint64(len(s.tree.levels[l])) {
- res = s.tree.levels[l][i]
+ if i < uint64(len(s.tree.Levels[l])) {
+ res = s.tree.Levels[l][i]
}
s.hints = append(s.hints, res)
return
}
-// partialLayer represents a subset of a layer (i.e., nodes at some
+// partialLayer represents a subset of a Layer (i.e., nodes at some
// level in the Merkle tree). layerItem represents one element in the
-// partial layer.
+// partial Layer.
+//msgp:ignore partialLayer
type partialLayer []layerItem
type layerItem struct {
pos uint64
- hash crypto.Digest
+ hash crypto.GenericDigest
}
-// up takes a partial layer at level l, and returns the next-higher (partial)
-// level in the tree. Since the layer is partial, up() requires siblings.
+// up takes a partial Layer at level l, and returns the next-higher (partial)
+// level in the tree. Since the Layer is partial, up() requires siblings.
//
// The implementation is deterministic to ensure that up() asks for siblings
// in the same order both when generating a proof, as well as when checking
@@ -77,7 +79,7 @@ type layerItem struct {
//
// If doHash is false, fill in zero hashes, which suffices for constructing
// a proof.
-func (pl partialLayer) up(s *siblings, l uint64, doHash bool) (partialLayer, error) {
+func (pl partialLayer) up(s *siblings, l uint64, doHash bool, hsh hash.Hash) (partialLayer, error) {
var res partialLayer
for i := 0; i < len(pl); i++ {
item := pl[i]
@@ -85,9 +87,9 @@ func (pl partialLayer) up(s *siblings, l uint64, doHash bool) (partialLayer, err
posHash := item.hash
siblingPos := pos ^ 1
- var siblingHash crypto.Digest
+ var siblingHash crypto.GenericDigest
if i+1 < len(pl) && pl[i+1].pos == siblingPos {
- // If our sibling is also in the partial layer, use its
+ // If our sibling is also in the partial Layer, use its
// hash (and skip over its position).
siblingHash = pl[i+1].hash
i++
@@ -101,7 +103,7 @@ func (pl partialLayer) up(s *siblings, l uint64, doHash bool) (partialLayer, err
}
nextLayerPos := pos / 2
- var nextLayerHash crypto.Digest
+ var nextLayerHash crypto.GenericDigest
if doHash {
var p pair
@@ -114,7 +116,7 @@ func (pl partialLayer) up(s *siblings, l uint64, doHash bool) (partialLayer, err
p.l = siblingHash
p.r = posHash
}
- nextLayerHash = p.Hash()
+ nextLayerHash = crypto.GenereicHashObj(hsh, &p)
}
res = append(res, layerItem{
diff --git a/crypto/merklearray/worker.go b/crypto/merklearray/worker.go
index 67f6aa0c5..e3d915f9a 100644
--- a/crypto/merklearray/worker.go
+++ b/crypto/merklearray/worker.go
@@ -68,11 +68,6 @@ func (ws *workerState) next(delta uint64) uint64 {
return atomic.AddUint64(&ws.nextidx, delta) - delta
}
-// When a worker is about to exit, it should call done.
-func (ws *workerState) done() {
- ws.wg.Done()
-}
-
// wait waits for all of the workers to finish.
func (ws *workerState) wait() {
ws.wg.Wait()
diff --git a/crypto/merklekeystore/const.go b/crypto/merklekeystore/const.go
new file mode 100644
index 000000000..c15ec862b
--- /dev/null
+++ b/crypto/merklekeystore/const.go
@@ -0,0 +1,25 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package merklekeystore
+
+import "github.com/algorand/go-algorand/crypto"
+
+// HashType/ hashSize relate to the type of hash this package uses.
+const (
+ KeyStoreHashFunction = crypto.Sha512_256
+ KeyStoreRootSize = crypto.Sha512_256Size
+)
diff --git a/crypto/merklekeystore/keystore.go b/crypto/merklekeystore/keystore.go
new file mode 100644
index 000000000..002c727e0
--- /dev/null
+++ b/crypto/merklekeystore/keystore.go
@@ -0,0 +1,295 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package merklekeystore
+
+import (
+ "errors"
+
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklearray"
+ "github.com/algorand/go-algorand/protocol"
+ "github.com/algorand/go-deadlock"
+)
+
+type (
+ // CommittablePublicKey is a key tied to a specific round and is committed by the merklekeystore.Signer.
+ CommittablePublicKey struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ VerifyingKey crypto.VerifyingKey `codec:"pk"`
+ Round uint64 `codec:"rnd"`
+ }
+
+ //Proof represent the merkle proof in each signature.
+ Proof merklearray.Proof
+
+ // Signature is a byte signature on a crypto.Hashable object,
+ // crypto.VerifyingKey and includes a merkle proof for the key.
+ Signature struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+ crypto.ByteSignature `codec:"bsig"`
+
+ Proof Proof `codec:"prf"`
+ VerifyingKey crypto.VerifyingKey `codec:"vkey"`
+ }
+
+ // Signer is a merkleKeyStore, contain multiple keys which can be used per round.
+ // Signer will generate all keys in the range [A,Z] that are divisible by some divisor d.
+ // in case A equals zero then signer will generate all keys from (0,Z], i.e will not generate key for round zero.
+ Signer struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+ // these keys are the keys used to sign in a round.
+ // should be disposed of once possible.
+ SignatureAlgorithms []crypto.SignatureAlgorithm `codec:"sks,allocbound=-"`
+ // the first round is used to set up the intervals.
+ FirstValid uint64 `codec:"rnd"`
+ // Used to align a position to a shrank array.
+ ArrayBase uint64 `codec:"az"`
+ Interval uint64 `codec:"iv"`
+
+ Tree merklearray.Tree `codec:"tree"`
+ mu deadlock.RWMutex
+ }
+
+ // Verifier Is a way to verify a Signature produced by merklekeystore.Signer.
+ // it also serves as a commit over all keys contained in the merklekeystore.Signer.
+ Verifier struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ Root [KeyStoreRootSize]byte `codec:"r"`
+
+ // indicates that this verifier corresponds to a specific array of ephemeral keys.
+ // this is used to distinguish between an empty structure, and nothing to commit to.
+ HasValidRoot bool `codec:"vr"`
+ }
+)
+
+var errStartBiggerThanEndRound = errors.New("cannot create merkleKeyStore because end round is smaller then start round")
+var errReceivedRoundIsBeforeFirst = errors.New("round translated to be prior to first key position")
+var errOutOfBounds = errors.New("round translated to be after last key position")
+var errNonExistantKey = errors.New("key doesn't exist")
+var errDivisorIsZero = errors.New("received zero Interval")
+var errCannotVerify = errors.New("verifier isn't valid")
+
+// ToBeHashed implementation means CommittablePublicKey is crypto.Hashable.
+func (e *CommittablePublicKey) ToBeHashed() (protocol.HashID, []byte) {
+ return protocol.EphemeralPK, protocol.Encode(e)
+}
+
+//Length returns the amount of disposable keys
+func (s *Signer) Length() uint64 {
+ return uint64(len(s.SignatureAlgorithms))
+}
+
+// Marshal Gets []byte to represent a VerifyingKey tied to the signatureAlgorithm in a pos.
+// used to implement the merklearray.Array interface needed to build a tree.
+func (s *Signer) Marshal(pos uint64) ([]byte, error) {
+ signer, err := s.SignatureAlgorithms[pos].GetSigner()
+ if err != nil {
+ return nil, err
+ }
+ ephPK := CommittablePublicKey{
+ VerifyingKey: *signer.GetVerifyingKey(),
+ Round: indexToRound(s.FirstValid, s.Interval, pos),
+ }
+
+ return crypto.HashRep(&ephPK), nil
+}
+
+// New Generates a merklekeystore.Signer
+// The function allow creation of empty signers, i.e signers without any key to sign with.
+// keys can be created between [A,Z], if A == 0, keys created will be in the range (0,Z]
+func New(firstValid, lastValid, interval uint64, sigAlgoType crypto.AlgorithmType) (*Signer, error) {
+ if firstValid > lastValid {
+ return nil, errStartBiggerThanEndRound
+ }
+ if interval == 0 {
+ return nil, errDivisorIsZero
+ }
+ if firstValid == 0 {
+ firstValid = 1
+ }
+
+ // calculates the number of indices from first valid round and up to lastValid.
+ // writing this explicit calculation to avoid overflow.
+ numberOfKeys := lastValid/interval - ((firstValid - 1) / interval)
+ keys := make([]crypto.SignatureAlgorithm, numberOfKeys)
+ for i := range keys {
+ sigAlgo, err := crypto.NewSigner(sigAlgoType)
+ if err != nil {
+ return nil, err
+ }
+ keys[i] = *sigAlgo
+ }
+ s := &Signer{
+ SignatureAlgorithms: keys,
+ FirstValid: firstValid,
+ ArrayBase: 0,
+ Interval: interval,
+ mu: deadlock.RWMutex{},
+ }
+ tree, err := merklearray.Build(s, crypto.HashFactory{HashType: KeyStoreHashFunction})
+ if err != nil {
+ return nil, err
+ }
+
+ s.Tree = *tree
+ return s, nil
+}
+
+// GetVerifier can be used to store the commitment and verifier for this signer.
+func (s *Signer) GetVerifier() *Verifier {
+ root := [KeyStoreRootSize]byte{}
+ ss := s.Tree.Root().ToSlice()
+ copy(root[:], ss)
+ return &Verifier{
+ Root: root,
+ HasValidRoot: true,
+ }
+}
+
+// Sign outputs a signature + proof for the signing key.
+func (s *Signer) Sign(hashable crypto.Hashable, round uint64) (Signature, error) {
+ s.mu.RLock()
+ defer s.mu.RUnlock()
+
+ pos, err := s.getArrayIndex(round)
+ if err != nil {
+ return Signature{}, err
+ }
+ signingKey, err := s.SignatureAlgorithms[pos].GetSigner()
+ if err != nil {
+ return Signature{}, err
+ }
+
+ index := s.getMerkleTreeIndex(round)
+ proof, err := s.Tree.Prove([]uint64{index})
+ if err != nil {
+ return Signature{}, err
+ }
+
+ return Signature{
+ ByteSignature: signingKey.Sign(hashable),
+ Proof: Proof(*proof),
+ VerifyingKey: *signingKey.GetVerifyingKey(),
+ }, nil
+}
+
+// expects valid rounds, i.e round that are bigger than FirstValid.
+func (s *Signer) getMerkleTreeIndex(round uint64) uint64 {
+ return roundToIndex(s.FirstValid, round, s.Interval)
+}
+
+func (s *Signer) getArrayIndex(round uint64) (uint64, error) {
+ if round < s.FirstValid {
+ return 0, errReceivedRoundIsBeforeFirst
+ }
+ pos := roundToIndex(s.FirstValid, round, s.Interval)
+ pos = pos - s.ArrayBase
+ if round%s.Interval != 0 {
+ return pos, errNonExistantKey
+ }
+ if pos >= uint64(len(s.SignatureAlgorithms)) {
+ return 0, errOutOfBounds
+ }
+ return pos, nil
+}
+
+// Trim shortness deletes keys that existed before a specific round,
+// will return an error for non existing keys/ out of bounds keys.
+// the output is a copy of the signer - which can be persisted.
+func (s *Signer) Trim(before uint64) (*Signer, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ pos, err := s.getArrayIndex(before)
+ if err != nil {
+ return nil, err
+ }
+ s.dropKeys(int(pos))
+
+ // the array base represents the leaf index that we can treat as first leaf after trimming the ephemeral keys array.
+ s.ArrayBase = s.getMerkleTreeIndex(before) + 1
+ cpy := s.copy()
+
+ // Swapping the keys (both of them are the same, but the one in cpy doesn't contain a dangling array behind it.
+ // e.g: A=A[len(A)-20:] doesn't mean the garbage collector will free parts of memory from the array.
+ // assuming that cpy will be used briefly and then dropped - it's better to swap their key slices.
+ s.SignatureAlgorithms, cpy.SignatureAlgorithms =
+ cpy.SignatureAlgorithms, s.SignatureAlgorithms
+
+ return cpy, nil
+}
+
+func (s *Signer) copy() *Signer {
+ signerCopy := Signer{
+ _struct: struct{}{},
+
+ SignatureAlgorithms: make([]crypto.SignatureAlgorithm, len(s.SignatureAlgorithms)),
+ FirstValid: s.FirstValid,
+ Interval: s.Interval,
+ ArrayBase: s.ArrayBase,
+
+ Tree: s.Tree,
+ mu: deadlock.RWMutex{},
+ }
+
+ copy(signerCopy.SignatureAlgorithms, s.SignatureAlgorithms)
+ return &signerCopy
+}
+
+func (s *Signer) dropKeys(upTo int) {
+ for i := 0; i <= upTo; i++ {
+ // zero the keys.
+ s.SignatureAlgorithms[i] = crypto.SignatureAlgorithm{}
+ }
+ s.SignatureAlgorithms = s.SignatureAlgorithms[upTo+1:]
+}
+
+// Verify receives a signature over a specific crypto.Hashable object, and makes certain the signature is correct.
+func (v *Verifier) Verify(firstValid, round, interval uint64, obj crypto.Hashable, sig Signature) error {
+ if !v.HasValidRoot {
+ return errCannotVerify
+ }
+ if firstValid == 0 {
+ firstValid = 1
+ }
+ if round < firstValid {
+ return errReceivedRoundIsBeforeFirst
+ }
+
+ ephkey := CommittablePublicKey{
+ VerifyingKey: sig.VerifyingKey,
+ Round: round,
+ }
+
+ pos := roundToIndex(firstValid, round, interval)
+ isInTree := merklearray.Verify(
+ (crypto.GenericDigest)(v.Root[:]),
+ map[uint64]crypto.Hashable{pos: &ephkey},
+ (*merklearray.Proof)(&sig.Proof),
+ )
+ if isInTree != nil {
+ return isInTree
+ }
+
+ ver, err := sig.VerifyingKey.GetVerifier()
+ if err != nil {
+ return err
+ }
+ return ver.Verify(obj, sig.ByteSignature)
+}
diff --git a/crypto/merklekeystore/keystore_test.go b/crypto/merklekeystore/keystore_test.go
new file mode 100644
index 000000000..554659298
--- /dev/null
+++ b/crypto/merklekeystore/keystore_test.go
@@ -0,0 +1,463 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package merklekeystore
+
+import (
+ "crypto/rand"
+ "math"
+ "testing"
+
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/protocol"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSignerCreation(t *testing.T) {
+ a := require.New(t)
+
+ h := genHashableForTest()
+ for i := uint64(1); i < 20; i++ {
+ signer, err := New(i, i+1, 1, crypto.Ed25519Type)
+ a.NoError(err)
+ _, err = signer.Sign(h, i)
+ a.NoError(err)
+ }
+
+ signer, err := New(0, 0, 1, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(0, len(signer.SignatureAlgorithms))
+
+ signer, err = New(0, 1, 1, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(uint64(1), signer.FirstValid)
+ a.Equal(1, len(signer.SignatureAlgorithms))
+
+ _, err = New(1, 0, 1, crypto.Ed25519Type)
+ a.Error(err)
+
+ signer, err = New(2, 2, 2, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(1, len(signer.SignatureAlgorithms))
+
+ sig, err := signer.Sign(genHashableForTest(), 2)
+ a.NoError(err)
+ a.NoError(signer.GetVerifier().Verify(2, 2, 2, genHashableForTest(), sig))
+
+ signer, err = New(2, 2, 3, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(0, len(signer.SignatureAlgorithms))
+
+ _, err = signer.Sign(genHashableForTest(), 2)
+ a.Error(err)
+
+ s, err := New(8, 21, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(len(s.SignatureAlgorithms), 2)
+
+ s, err = New(8, 20, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(len(s.SignatureAlgorithms), 2)
+
+ s, err = New(10, 21, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(len(s.SignatureAlgorithms), 2)
+
+ s, err = New(10, 20, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(len(s.SignatureAlgorithms), 2)
+
+ s, err = New(11, 20, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(len(s.SignatureAlgorithms), 1)
+
+ s, err = New(11, 19, 10, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(0, len(s.SignatureAlgorithms))
+ _, err = signer.Sign(genHashableForTest(), 2)
+ a.Error(err)
+}
+func TestEmptyVerifier(t *testing.T) {
+ a := require.New(t)
+
+ signer, err := New(8, 9, 5, crypto.Ed25519Type)
+ a.NoError(err)
+ a.NotEqual(*signer.GetVerifier(), Verifier{})
+
+}
+func TestEmptySigner(t *testing.T) {
+ a := require.New(t)
+
+ h := genHashableForTest()
+ signer, err := New(8, 9, 5, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(0, len(signer.SignatureAlgorithms))
+
+ _, err = signer.Sign(h, 8)
+ a.Error(err)
+
+ _, err = signer.Sign(h, 9)
+ a.Error(err)
+
+ _, err = signer.Trim(10)
+ a.Error(err)
+}
+
+func TestDisposableKeyPositions(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(0, 100, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ for i := uint64(1); i < 100; i++ {
+ pos, err := signer.getArrayIndex(i)
+ a.NoError(err, i)
+ a.Equal(i-1, pos)
+ }
+
+ _, err = signer.getArrayIndex(101)
+ a.Error(err)
+
+ signer, err = New(1000, 1100, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ for i := uint64(1000); i < 1100; i++ {
+ pos, err := signer.getArrayIndex(i)
+ a.NoError(err, i)
+ a.Equal(i-1000, pos)
+ }
+
+ _, err = signer.getArrayIndex(999)
+ a.Error(err)
+
+ signer, err = New(1000, 1100, 101, crypto.Ed25519Type)
+ a.NoError(err)
+
+ indices := make([]uint64, 0)
+ for i := uint64(1000); i <= 1100; i++ {
+ if i%101 == 0 {
+ indices = append(indices, i)
+ continue
+ }
+ _, err := signer.getArrayIndex(i)
+ a.Error(err, i)
+ }
+
+ for index, round := range indices {
+ pos, err := signer.getArrayIndex(round)
+ a.NoError(err)
+ a.Equal(uint64(index), pos)
+ }
+}
+
+func TestNonEmptyDisposableKeys(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(0, 100, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ s := crypto.SignatureAlgorithm{}
+ for _, key := range signer.SignatureAlgorithms {
+ a.NotEqual(s, key)
+ }
+}
+
+func TestSignatureStructure(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(50, 100, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ hashable := genHashableForTest()
+ sig, err := signer.Sign(hashable, 51)
+ a.NoError(err)
+
+ pos, err := signer.getArrayIndex(51)
+ a.NoError(err)
+ a.Equal(uint64(1), pos)
+
+ key := signer.SignatureAlgorithms[pos]
+ signingkey, err := key.GetSigner()
+ a.NoError(err)
+ a.Equal(sig.VerifyingKey, *signingkey.GetVerifyingKey())
+
+ proof, err := signer.Tree.Prove([]uint64{1})
+ a.NoError(err)
+ a.Equal(Proof(*proof), sig.Proof)
+
+ a.NotEqual(nil, sig.ByteSignature)
+}
+
+func genHashableForTest() crypto.Hashable {
+ hashable := crypto.Hashable(&crypto.VerifyingKey{Type: math.MaxUint64}) // just want some crypto.Hashable..
+ return hashable
+}
+
+func TestSigning(t *testing.T) {
+ a := require.New(t)
+
+ start, end := uint64(50), uint64(100)
+ signer, err := New(start, end, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ hashable := crypto.Hashable(&crypto.VerifyingKey{Type: math.MaxUint64}) // just want some crypto.Hashable..
+
+ sig, err := signer.Sign(hashable, start)
+ a.NoError(err)
+ a.NoError(signer.GetVerifier().Verify(start, start, 1, hashable, sig))
+
+ _, err = signer.Sign(hashable, start-1)
+ a.Error(err)
+
+ _, err = signer.Sign(hashable, end+1)
+ a.Error(err)
+
+ signer, err = New(start, end, 10, crypto.Ed25519Type)
+ a.NoError(err)
+
+ sig, err = signer.Sign(hashable, start)
+ a.NoError(err)
+ a.NoError(signer.GetVerifier().Verify(start, start, 1, hashable, sig))
+
+ sig, err = signer.Sign(hashable, start+5)
+ a.Error(err)
+ a.Error(signer.GetVerifier().Verify(start, start+5, 1, hashable, sig))
+
+ signer, err = New(50, 100, 12, crypto.Ed25519Type)
+ a.NoError(err)
+
+ for i := uint64(50); i < 100; i++ {
+ if i%12 != 0 {
+ _, err = signer.Sign(hashable, i)
+ a.Error(err)
+ } else {
+ sig, err = signer.Sign(hashable, i)
+ a.NoError(err)
+ a.NoError(signer.GetVerifier().Verify(50, i, 12, hashable, sig))
+ }
+ }
+}
+
+func TestBadRound(t *testing.T) {
+ a := require.New(t)
+ start, _, signer := getSigner(a)
+
+ hashable, sig := makeSig(signer, start, a)
+
+ a.Error(signer.GetVerifier().Verify(0, start, 1, hashable, sig))
+ a.Error(signer.GetVerifier().Verify(start, start+1, 1, hashable, sig))
+
+ hashable, sig = makeSig(signer, start+1, a)
+ a.Error(signer.GetVerifier().Verify(start, start, 1, hashable, sig))
+ a.Error(signer.GetVerifier().Verify(start, start+2, 1, hashable, sig))
+}
+
+func TestBadMerkleProofInSignature(t *testing.T) {
+ a := require.New(t)
+ start, _, signer := getSigner(a)
+
+ hashable, sig := makeSig(signer, start, a)
+
+ sig2 := copySig(sig)
+ sig2.Proof.Path = sig2.Proof.Path[:len(sig2.Proof.Path)-1]
+ a.Error(signer.GetVerifier().Verify(start, start, 1, hashable, sig2))
+
+ sig3 := copySig(sig)
+ someDigest := crypto.Digest{}
+ rand.Read(someDigest[:])
+ sig3.Proof.Path[0] = someDigest[:]
+ a.Error(signer.GetVerifier().Verify(start, start, 1, hashable, sig3))
+}
+
+func copySig(sig Signature) Signature {
+ bsig := make([]byte, len(sig.ByteSignature))
+ copy(bsig, sig.ByteSignature)
+
+ return Signature{
+ ByteSignature: bsig,
+ Proof: copyProof(sig.Proof),
+ VerifyingKey: sig.VerifyingKey,
+ }
+}
+
+func copyProof(proof Proof) Proof {
+ path := make([]crypto.GenericDigest, len(proof.Path))
+ for i, digest := range proof.Path {
+ path[i] = make([]byte, len(digest))
+ copy(path[i], digest)
+ }
+ return Proof{
+ Path: path,
+ HashFactory: proof.HashFactory,
+ }
+}
+
+func TestIncorrectByteSignature(t *testing.T) {
+ a := require.New(t)
+ start, _, signer := getSigner(a)
+
+ hashable, sig := makeSig(signer, start, a)
+
+ sig2 := sig
+ bs := make([]byte, len(sig.ByteSignature))
+ copy(bs, sig2.ByteSignature)
+ bs[0]++
+ sig2.ByteSignature = bs
+ a.Error(signer.GetVerifier().Verify(start, start, 1, hashable, sig2))
+}
+
+func TestAttemptToUseDifferentKey(t *testing.T) {
+ a := require.New(t)
+ start, _, signer := getSigner(a)
+
+ hashable, sig := makeSig(signer, start+1, a)
+ // taking signature for specific round and changing the round
+
+ // taking signature and changing the key to match different round
+ sig2 := sig
+ signingKey, err := signer.SignatureAlgorithms[0].GetSigner()
+ a.NoError(err)
+ sig2.VerifyingKey = *signingKey.GetVerifyingKey()
+ a.Error(signer.GetVerifier().Verify(start, start+1, 1, hashable, sig2))
+}
+
+func TestMarshal(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(0, 10, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ out := protocol.Encode(signer)
+ decodeInto := &Signer{}
+ a.NoError(protocol.Decode(out, decodeInto))
+ a.Equal(signer, decodeInto)
+
+ // check that after trim the output stays the same.
+ cpy, _ := signer.Trim(5)
+ a.Equal(protocol.Encode(signer), protocol.Encode(cpy))
+
+ verifier := signer.GetVerifier()
+ bs := protocol.Encode(verifier)
+ verifierToDecodeInto := Verifier{}
+ protocol.Decode(bs, &verifierToDecodeInto)
+ a.Equal(*verifier, verifierToDecodeInto)
+}
+
+func TestKeySliceAfterSignerTrim(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(1, 100, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ cpy, _ := signer.Trim(1)
+ a.Equal(cpy.FirstValid, uint64(1))
+ a.Equal(len(cpy.SignatureAlgorithms), 99)
+
+ cpy, _ = signer.Trim(10)
+ a.Equal(cpy.FirstValid, uint64(1))
+ a.Equal(cpy.ArrayBase, uint64(10))
+ a.Equal(len(cpy.SignatureAlgorithms), 90)
+ a.Equal(signer.FirstValid, uint64(1))
+ a.Equal(len(signer.SignatureAlgorithms), 90)
+
+ cpy, _ = signer.Trim(20)
+ a.Equal(cpy.FirstValid, uint64(1))
+ a.Equal(cpy.ArrayBase, uint64(20))
+ a.Equal(len(cpy.SignatureAlgorithms), 80)
+ a.Equal(signer.FirstValid, uint64(1))
+ a.Equal(len(signer.SignatureAlgorithms), 80)
+
+ _, err = signer.Trim(101)
+ a.Error(err)
+
+ signer, err = New(1, 100, 11, crypto.Ed25519Type)
+ a.NoError(err)
+ a.Equal(9, len(signer.SignatureAlgorithms))
+
+ // Should not trim, removes only keys from before current round
+ signer.Trim(11)
+ a.Equal(signer.FirstValid, uint64(1))
+ a.Equal(8, len(signer.SignatureAlgorithms))
+
+ signer.Trim(22)
+ a.Equal(signer.FirstValid, uint64(1))
+ a.Equal(7, len(signer.SignatureAlgorithms))
+
+ _, err = signer.Trim(23)
+ a.Error(err)
+
+ signer.Trim(99)
+ a.Equal(signer.FirstValid, uint64(1))
+ a.Equal(len(signer.SignatureAlgorithms), 0)
+
+ // create signer and delete all keys.
+ signer, err = New(1, 60, 1, crypto.Ed25519Type)
+ a.NoError(err)
+ _, err = signer.Trim(60)
+ a.NoError(err)
+ a.Equal(0, len(signer.SignatureAlgorithms))
+
+ signer, err = New(1, 60, 11, crypto.Ed25519Type)
+ a.NoError(err)
+ _, err = signer.Trim(55)
+ a.NoError(err)
+ a.Equal(0, len(signer.SignatureAlgorithms))
+
+}
+
+func TestKeyDeletion(t *testing.T) {
+ a := require.New(t)
+ signer, err := New(1, 60, 1, crypto.Ed25519Type)
+ a.NoError(err)
+
+ signer.Trim(50)
+ _, err = signer.Sign(genHashableForTest(), 50)
+ a.Error(err)
+
+ for i := uint64(51); i <= 60; i++ {
+ sig, err := signer.Sign(genHashableForTest(), i)
+ a.NoError(err)
+
+ a.NoError(signer.GetVerifier().Verify(1, i, 1, genHashableForTest(), sig))
+ }
+
+ signer, err = New(1, 60, 11, crypto.Ed25519Type)
+ a.NoError(err)
+
+ signer.Trim(50)
+ _, err = signer.Sign(genHashableForTest(), 49)
+ a.Error(err)
+
+ for i := uint64(50); i <= 60; i++ {
+ sig, err := signer.Sign(genHashableForTest(), i)
+ if i%11 != 0 {
+ a.Error(err)
+ continue
+ }
+ a.NoError(signer.GetVerifier().Verify(1, i, 11, genHashableForTest(), sig))
+ }
+}
+
+func makeSig(signer *Signer, sigRound uint64, a *require.Assertions) (crypto.Hashable, Signature) {
+ hashable := crypto.Hashable(&crypto.VerifyingKey{Type: math.MaxUint64}) // just want some crypto.Hashable..
+
+ sig, err := signer.Sign(hashable, sigRound)
+ a.NoError(err)
+ a.NoError(signer.GetVerifier().Verify(signer.FirstValid, sigRound, 1, hashable, sig))
+ return hashable, sig
+}
+
+func getSigner(a *require.Assertions) (uint64, uint64, *Signer) {
+ start, end := uint64(50), uint64(100)
+ signer, err := New(start, end, 1, crypto.Ed25519Type)
+ a.NoError(err)
+ return start, end, signer
+}
diff --git a/crypto/merklekeystore/msgp_gen.go b/crypto/merklekeystore/msgp_gen.go
new file mode 100644
index 000000000..d5a7c2075
--- /dev/null
+++ b/crypto/merklekeystore/msgp_gen.go
@@ -0,0 +1,730 @@
+package merklekeystore
+
+// Code generated by github.com/algorand/msgp DO NOT EDIT.
+
+import (
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklearray"
+ "github.com/algorand/msgp/msgp"
+)
+
+// The following msgp objects are implemented in this file:
+// CommittablePublicKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Proof
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Signature
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Signer
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Verifier
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+
+// MarshalMsg implements msgp.Marshaler
+func (z *CommittablePublicKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(2)
+ var zb0001Mask uint8 /* 3 bits */
+ if (*z).VerifyingKey.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ if (*z).Round == 0 {
+ zb0001Len--
+ zb0001Mask |= 0x4
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "pk"
+ o = append(o, 0xa2, 0x70, 0x6b)
+ o = (*z).VerifyingKey.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
+ // string "rnd"
+ o = append(o, 0xa3, 0x72, 0x6e, 0x64)
+ o = msgp.AppendUint64(o, (*z).Round)
+ }
+ }
+ return
+}
+
+func (_ *CommittablePublicKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*CommittablePublicKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *CommittablePublicKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).VerifyingKey.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "VerifyingKey")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ (*z).Round, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Round")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = CommittablePublicKey{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "pk":
+ bts, err = (*z).VerifyingKey.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "VerifyingKey")
+ return
+ }
+ case "rnd":
+ (*z).Round, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Round")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *CommittablePublicKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*CommittablePublicKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *CommittablePublicKey) Msgsize() (s int) {
+ s = 1 + 3 + (*z).VerifyingKey.Msgsize() + 4 + msgp.Uint64Size
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *CommittablePublicKey) MsgIsZero() bool {
+ return ((*z).VerifyingKey.MsgIsZero()) && ((*z).Round == 0)
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Proof) MarshalMsg(b []byte) []byte {
+ return ((*(merklearray.Proof))(z)).MarshalMsg(b)
+}
+func (_ *Proof) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Proof)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Proof) UnmarshalMsg(bts []byte) ([]byte, error) {
+ return ((*(merklearray.Proof))(z)).UnmarshalMsg(bts)
+}
+func (_ *Proof) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Proof)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Proof) Msgsize() int {
+ return ((*(merklearray.Proof))(z)).Msgsize()
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Proof) MsgIsZero() bool {
+ return ((*(merklearray.Proof))(z)).MsgIsZero()
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Signature) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(3)
+ var zb0001Mask uint8 /* 4 bits */
+ if (*z).ByteSignature.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ if (*z).Proof.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x4
+ }
+ if (*z).VerifyingKey.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x8
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "bsig"
+ o = append(o, 0xa4, 0x62, 0x73, 0x69, 0x67)
+ o = (*z).ByteSignature.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
+ // string "prf"
+ o = append(o, 0xa3, 0x70, 0x72, 0x66)
+ o = (*z).Proof.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x8) == 0 { // if not empty
+ // string "vkey"
+ o = append(o, 0xa4, 0x76, 0x6b, 0x65, 0x79)
+ o = (*z).VerifyingKey.MarshalMsg(o)
+ }
+ }
+ return
+}
+
+func (_ *Signature) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Signature)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Signature) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).ByteSignature.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "ByteSignature")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).Proof.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proof")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).VerifyingKey.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "VerifyingKey")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = Signature{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "bsig":
+ bts, err = (*z).ByteSignature.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "ByteSignature")
+ return
+ }
+ case "prf":
+ bts, err = (*z).Proof.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proof")
+ return
+ }
+ case "vkey":
+ bts, err = (*z).VerifyingKey.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "VerifyingKey")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Signature) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Signature)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Signature) Msgsize() (s int) {
+ s = 1 + 5 + (*z).ByteSignature.Msgsize() + 4 + (*z).Proof.Msgsize() + 5 + (*z).VerifyingKey.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Signature) MsgIsZero() bool {
+ return ((*z).ByteSignature.MsgIsZero()) && ((*z).Proof.MsgIsZero()) && ((*z).VerifyingKey.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Signer) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(5)
+ var zb0002Mask uint8 /* 7 bits */
+ if (*z).ArrayBase == 0 {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ if (*z).Interval == 0 {
+ zb0002Len--
+ zb0002Mask |= 0x4
+ }
+ if (*z).FirstValid == 0 {
+ zb0002Len--
+ zb0002Mask |= 0x10
+ }
+ if len((*z).SignatureAlgorithms) == 0 {
+ zb0002Len--
+ zb0002Mask |= 0x20
+ }
+ if (*z).Tree.MsgIsZero() {
+ zb0002Len--
+ zb0002Mask |= 0x40
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "az"
+ o = append(o, 0xa2, 0x61, 0x7a)
+ o = msgp.AppendUint64(o, (*z).ArrayBase)
+ }
+ if (zb0002Mask & 0x4) == 0 { // if not empty
+ // string "iv"
+ o = append(o, 0xa2, 0x69, 0x76)
+ o = msgp.AppendUint64(o, (*z).Interval)
+ }
+ if (zb0002Mask & 0x10) == 0 { // if not empty
+ // string "rnd"
+ o = append(o, 0xa3, 0x72, 0x6e, 0x64)
+ o = msgp.AppendUint64(o, (*z).FirstValid)
+ }
+ if (zb0002Mask & 0x20) == 0 { // if not empty
+ // string "sks"
+ o = append(o, 0xa3, 0x73, 0x6b, 0x73)
+ if (*z).SignatureAlgorithms == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).SignatureAlgorithms)))
+ }
+ for zb0001 := range (*z).SignatureAlgorithms {
+ o = (*z).SignatureAlgorithms[zb0001].MarshalMsg(o)
+ }
+ }
+ if (zb0002Mask & 0x40) == 0 { // if not empty
+ // string "tree"
+ o = append(o, 0xa4, 0x74, 0x72, 0x65, 0x65)
+ o = (*z).Tree.MarshalMsg(o)
+ }
+ }
+ return
+}
+
+func (_ *Signer) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Signer)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Signer) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ var zb0004 int
+ var zb0005 bool
+ zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SignatureAlgorithms")
+ return
+ }
+ if zb0005 {
+ (*z).SignatureAlgorithms = nil
+ } else if (*z).SignatureAlgorithms != nil && cap((*z).SignatureAlgorithms) >= zb0004 {
+ (*z).SignatureAlgorithms = ((*z).SignatureAlgorithms)[:zb0004]
+ } else {
+ (*z).SignatureAlgorithms = make([]crypto.SignatureAlgorithm, zb0004)
+ }
+ for zb0001 := range (*z).SignatureAlgorithms {
+ bts, err = (*z).SignatureAlgorithms[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SignatureAlgorithms", zb0001)
+ return
+ }
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ (*z).FirstValid, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FirstValid")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ (*z).ArrayBase, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "ArrayBase")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ (*z).Interval, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Interval")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ bts, err = (*z).Tree.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Tree")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = Signer{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "sks":
+ var zb0006 int
+ var zb0007 bool
+ zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SignatureAlgorithms")
+ return
+ }
+ if zb0007 {
+ (*z).SignatureAlgorithms = nil
+ } else if (*z).SignatureAlgorithms != nil && cap((*z).SignatureAlgorithms) >= zb0006 {
+ (*z).SignatureAlgorithms = ((*z).SignatureAlgorithms)[:zb0006]
+ } else {
+ (*z).SignatureAlgorithms = make([]crypto.SignatureAlgorithm, zb0006)
+ }
+ for zb0001 := range (*z).SignatureAlgorithms {
+ bts, err = (*z).SignatureAlgorithms[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SignatureAlgorithms", zb0001)
+ return
+ }
+ }
+ case "rnd":
+ (*z).FirstValid, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FirstValid")
+ return
+ }
+ case "az":
+ (*z).ArrayBase, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "ArrayBase")
+ return
+ }
+ case "iv":
+ (*z).Interval, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Interval")
+ return
+ }
+ case "tree":
+ bts, err = (*z).Tree.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Tree")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Signer) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Signer)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Signer) Msgsize() (s int) {
+ s = 1 + 4 + msgp.ArrayHeaderSize
+ for zb0001 := range (*z).SignatureAlgorithms {
+ s += (*z).SignatureAlgorithms[zb0001].Msgsize()
+ }
+ s += 4 + msgp.Uint64Size + 3 + msgp.Uint64Size + 3 + msgp.Uint64Size + 5 + (*z).Tree.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Signer) MsgIsZero() bool {
+ return (len((*z).SignatureAlgorithms) == 0) && ((*z).FirstValid == 0) && ((*z).ArrayBase == 0) && ((*z).Interval == 0) && ((*z).Tree.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Verifier) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(2)
+ var zb0002Mask uint8 /* 3 bits */
+ if (*z).Root == ([KeyStoreRootSize]byte{}) {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ if (*z).HasValidRoot == false {
+ zb0002Len--
+ zb0002Mask |= 0x4
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "r"
+ o = append(o, 0xa1, 0x72)
+ o = msgp.AppendBytes(o, ((*z).Root)[:])
+ }
+ if (zb0002Mask & 0x4) == 0 { // if not empty
+ // string "vr"
+ o = append(o, 0xa2, 0x76, 0x72)
+ o = msgp.AppendBool(o, (*z).HasValidRoot)
+ }
+ }
+ return
+}
+
+func (_ *Verifier) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Verifier)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Verifier) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Root)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Root")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ (*z).HasValidRoot, bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = Verifier{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "r":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Root)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "Root")
+ return
+ }
+ case "vr":
+ (*z).HasValidRoot, bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Verifier) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Verifier)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Verifier) Msgsize() (s int) {
+ s = 1 + 2 + msgp.ArrayHeaderSize + (KeyStoreRootSize * (msgp.ByteSize)) + 3 + msgp.BoolSize
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Verifier) MsgIsZero() bool {
+ return ((*z).Root == ([KeyStoreRootSize]byte{})) && ((*z).HasValidRoot == false)
+}
diff --git a/crypto/merklekeystore/msgp_gen_test.go b/crypto/merklekeystore/msgp_gen_test.go
new file mode 100644
index 000000000..c8a74f96f
--- /dev/null
+++ b/crypto/merklekeystore/msgp_gen_test.go
@@ -0,0 +1,253 @@
+// +build !skip_msgp_testing
+
+package merklekeystore
+
+// Code generated by github.com/algorand/msgp DO NOT EDIT.
+
+import (
+ "testing"
+
+ "github.com/algorand/go-algorand/protocol"
+ "github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/algorand/msgp/msgp"
+)
+
+func TestMarshalUnmarshalCommittablePublicKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := CommittablePublicKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingCommittablePublicKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &CommittablePublicKey{})
+}
+
+func BenchmarkMarshalMsgCommittablePublicKey(b *testing.B) {
+ v := CommittablePublicKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgCommittablePublicKey(b *testing.B) {
+ v := CommittablePublicKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalCommittablePublicKey(b *testing.B) {
+ v := CommittablePublicKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalSignature(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Signature{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingSignature(t *testing.T) {
+ protocol.RunEncodingTest(t, &Signature{})
+}
+
+func BenchmarkMarshalMsgSignature(b *testing.B) {
+ v := Signature{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgSignature(b *testing.B) {
+ v := Signature{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalSignature(b *testing.B) {
+ v := Signature{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalSigner(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Signer{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingSigner(t *testing.T) {
+ protocol.RunEncodingTest(t, &Signer{})
+}
+
+func BenchmarkMarshalMsgSigner(b *testing.B) {
+ v := Signer{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgSigner(b *testing.B) {
+ v := Signer{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalSigner(b *testing.B) {
+ v := Signer{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalVerifier(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Verifier{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingVerifier(t *testing.T) {
+ protocol.RunEncodingTest(t, &Verifier{})
+}
+
+func BenchmarkMarshalMsgVerifier(b *testing.B) {
+ v := Verifier{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgVerifier(b *testing.B) {
+ v := Verifier{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalVerifier(b *testing.B) {
+ v := Verifier{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
diff --git a/crypto/merklekeystore/posdivs.go b/crypto/merklekeystore/posdivs.go
new file mode 100644
index 000000000..1a86e723d
--- /dev/null
+++ b/crypto/merklekeystore/posdivs.go
@@ -0,0 +1,25 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package merklekeystore
+
+func roundToIndex(firstValid, currentRound, interval uint64) uint64 {
+ return currentRound/interval - ((firstValid - 1) / interval) - 1
+}
+
+func indexToRound(firstValid, interval, pos uint64) uint64 {
+ return (((firstValid - 1) / interval) + 1 + pos) * interval
+}
diff --git a/crypto/msgp_gen.go b/crypto/msgp_gen.go
index 4690dbfc4..458587e97 100644
--- a/crypto/msgp_gen.go
+++ b/crypto/msgp_gen.go
@@ -6,10 +6,43 @@ import (
_ "runtime/cgo"
_ "unsafe"
+ cdilithium "github.com/algorand/dilithium/ref"
"github.com/algorand/msgp/msgp"
)
// The following msgp objects are implemented in this file:
+// AlgorithmType
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// ByteSignature
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// DPublicKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// DSecretKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
// Digest
// |-----> (*) MarshalMsg
// |-----> (*) CanMarshalMsg
@@ -18,6 +51,86 @@ import (
// |-----> (*) Msgsize
// |-----> (*) MsgIsZero
//
+// DilithiumPrivateKey
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// DilithiumPublicKey
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// DilithiumSignature
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// DilithiumSigner
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// DilithiumVerifier
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Ed25519Key
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// Ed25519PublicKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// GenericDigest
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
+// HashFactory
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// HashType
+// |-----> MarshalMsg
+// |-----> CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> Msgsize
+// |-----> MsgIsZero
+//
// MasterDerivationKey
// |-----> (*) MarshalMsg
// |-----> (*) CanMarshalMsg
@@ -90,6 +203,22 @@ import (
// |-----> (*) Msgsize
// |-----> (*) MsgIsZero
//
+// PackedSignatureAlgorithm
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
+// PackedVerifyingKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
// PrivateKey
// |-----> (*) MarshalMsg
// |-----> (*) CanMarshalMsg
@@ -122,6 +251,14 @@ import (
// |-----> (*) Msgsize
// |-----> (*) MsgIsZero
//
+// SignatureAlgorithm
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
// SignatureSecrets
// |-----> (*) MarshalMsg
// |-----> (*) CanMarshalMsg
@@ -138,6 +275,14 @@ import (
// |-----> (*) Msgsize
// |-----> (*) MsgIsZero
//
+// VerifyingKey
+// |-----> (*) MarshalMsg
+// |-----> (*) CanMarshalMsg
+// |-----> (*) UnmarshalMsg
+// |-----> (*) CanUnmarshalMsg
+// |-----> (*) Msgsize
+// |-----> (*) MsgIsZero
+//
// VrfOutput
// |-----> (*) MarshalMsg
// |-----> (*) CanMarshalMsg
@@ -212,6 +357,176 @@ import (
//
// MarshalMsg implements msgp.Marshaler
+func (z AlgorithmType) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendUint64(o, uint64(z))
+ return
+}
+
+func (_ AlgorithmType) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(AlgorithmType)
+ if !ok {
+ _, ok = (z).(*AlgorithmType)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *AlgorithmType) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 uint64
+ zb0001, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = AlgorithmType(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *AlgorithmType) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*AlgorithmType)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z AlgorithmType) Msgsize() (s int) {
+ s = msgp.Uint64Size
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z AlgorithmType) MsgIsZero() bool {
+ return z == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z ByteSignature) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, []byte(z))
+ return
+}
+
+func (_ ByteSignature) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(ByteSignature)
+ if !ok {
+ _, ok = (z).(*ByteSignature)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *ByteSignature) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 []byte
+ zb0001, bts, err = msgp.ReadBytesBytes(bts, []byte((*z)))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = ByteSignature(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *ByteSignature) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*ByteSignature)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z ByteSignature) Msgsize() (s int) {
+ s = msgp.BytesPrefixSize + len([]byte(z))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z ByteSignature) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *DPublicKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, (*z)[:])
+ return
+}
+
+func (_ *DPublicKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DPublicKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DPublicKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ bts, err = msgp.ReadExactBytes(bts, (*z)[:])
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ o = bts
+ return
+}
+
+func (_ *DPublicKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DPublicKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *DPublicKey) Msgsize() (s int) {
+ s = msgp.ArrayHeaderSize + (cdilithium.PublicKeySize * (msgp.ByteSize))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *DPublicKey) MsgIsZero() bool {
+ return (*z) == (DPublicKey{})
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *DSecretKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, (*z)[:])
+ return
+}
+
+func (_ *DSecretKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DSecretKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DSecretKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ bts, err = msgp.ReadExactBytes(bts, (*z)[:])
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ o = bts
+ return
+}
+
+func (_ *DSecretKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DSecretKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *DSecretKey) Msgsize() (s int) {
+ s = msgp.ArrayHeaderSize + (cdilithium.PrivateKeySize * (msgp.ByteSize))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *DSecretKey) MsgIsZero() bool {
+ return (*z) == (DSecretKey{})
+}
+
+// MarshalMsg implements msgp.Marshaler
func (z *Digest) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
o = msgp.AppendBytes(o, (*z)[:])
@@ -251,6 +566,931 @@ func (z *Digest) MsgIsZero() bool {
}
// MarshalMsg implements msgp.Marshaler
+func (z DilithiumPrivateKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, []byte(z))
+ return
+}
+
+func (_ DilithiumPrivateKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(DilithiumPrivateKey)
+ if !ok {
+ _, ok = (z).(*DilithiumPrivateKey)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DilithiumPrivateKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 []byte
+ zb0001, bts, err = msgp.ReadBytesBytes(bts, []byte((*z)))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = DilithiumPrivateKey(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *DilithiumPrivateKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumPrivateKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z DilithiumPrivateKey) Msgsize() (s int) {
+ s = msgp.BytesPrefixSize + len([]byte(z))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z DilithiumPrivateKey) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z DilithiumPublicKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, []byte(z))
+ return
+}
+
+func (_ DilithiumPublicKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(DilithiumPublicKey)
+ if !ok {
+ _, ok = (z).(*DilithiumPublicKey)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DilithiumPublicKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 []byte
+ zb0001, bts, err = msgp.ReadBytesBytes(bts, []byte((*z)))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = DilithiumPublicKey(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *DilithiumPublicKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumPublicKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z DilithiumPublicKey) Msgsize() (s int) {
+ s = msgp.BytesPrefixSize + len([]byte(z))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z DilithiumPublicKey) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z DilithiumSignature) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, []byte(z))
+ return
+}
+
+func (_ DilithiumSignature) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(DilithiumSignature)
+ if !ok {
+ _, ok = (z).(*DilithiumSignature)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DilithiumSignature) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 []byte
+ zb0001, bts, err = msgp.ReadBytesBytes(bts, []byte((*z)))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = DilithiumSignature(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *DilithiumSignature) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumSignature)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z DilithiumSignature) Msgsize() (s int) {
+ s = msgp.BytesPrefixSize + len([]byte(z))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z DilithiumSignature) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *DilithiumSigner) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0003Len := uint32(2)
+ var zb0003Mask uint8 /* 3 bits */
+ if (*z).PublicKey == (DPublicKey{}) {
+ zb0003Len--
+ zb0003Mask |= 0x2
+ }
+ if (*z).SecretKey == (DSecretKey{}) {
+ zb0003Len--
+ zb0003Mask |= 0x4
+ }
+ // variable map header, size zb0003Len
+ o = append(o, 0x80|uint8(zb0003Len))
+ if zb0003Len != 0 {
+ if (zb0003Mask & 0x2) == 0 { // if not empty
+ // string "pk"
+ o = append(o, 0xa2, 0x70, 0x6b)
+ o = msgp.AppendBytes(o, ((*z).PublicKey)[:])
+ }
+ if (zb0003Mask & 0x4) == 0 { // if not empty
+ // string "sk"
+ o = append(o, 0xa2, 0x73, 0x6b)
+ o = msgp.AppendBytes(o, ((*z).SecretKey)[:])
+ }
+ }
+ return
+}
+
+func (_ *DilithiumSigner) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumSigner)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DilithiumSigner) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0003 int
+ var zb0004 bool
+ zb0003, zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0003, zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 > 0 {
+ zb0003--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PublicKey")
+ return
+ }
+ }
+ if zb0003 > 0 {
+ zb0003--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).SecretKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SecretKey")
+ return
+ }
+ }
+ if zb0003 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0003)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0004 {
+ (*z) = DilithiumSigner{}
+ }
+ for zb0003 > 0 {
+ zb0003--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "pk":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "PublicKey")
+ return
+ }
+ case "sk":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).SecretKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "SecretKey")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *DilithiumSigner) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumSigner)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *DilithiumSigner) Msgsize() (s int) {
+ s = 1 + 3 + msgp.ArrayHeaderSize + (cdilithium.PublicKeySize * (msgp.ByteSize)) + 3 + msgp.ArrayHeaderSize + (cdilithium.PrivateKeySize * (msgp.ByteSize))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *DilithiumSigner) MsgIsZero() bool {
+ return ((*z).PublicKey == (DPublicKey{})) && ((*z).SecretKey == (DSecretKey{}))
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *DilithiumVerifier) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(1)
+ var zb0002Mask uint8 /* 2 bits */
+ if (*z).PublicKey == (DPublicKey{}) {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "k"
+ o = append(o, 0xa1, 0x6b)
+ o = msgp.AppendBytes(o, ((*z).PublicKey)[:])
+ }
+ }
+ return
+}
+
+func (_ *DilithiumVerifier) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumVerifier)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *DilithiumVerifier) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PublicKey")
+ return
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = DilithiumVerifier{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "k":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "PublicKey")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *DilithiumVerifier) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*DilithiumVerifier)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *DilithiumVerifier) Msgsize() (s int) {
+ s = 1 + 2 + msgp.ArrayHeaderSize + (cdilithium.PublicKeySize * (msgp.ByteSize))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *DilithiumVerifier) MsgIsZero() bool {
+ return ((*z).PublicKey == (DPublicKey{}))
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Ed25519Key) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(1)
+ var zb0002Mask uint8 /* 2 bits */
+ if ((*z).Sec.SignatureVerifier.MsgIsZero()) && ((*z).Sec.SK == (ed25519PrivateKey{})) {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "sec"
+ o = append(o, 0xa3, 0x73, 0x65, 0x63)
+ // map header, size 2
+ // string "SK"
+ o = append(o, 0x82, 0xa2, 0x53, 0x4b)
+ o = msgp.AppendBytes(o, ((*z).Sec.SK)[:])
+ // string "SignatureVerifier"
+ o = append(o, 0xb1, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x72)
+ o = (*z).Sec.SignatureVerifier.MarshalMsg(o)
+ }
+ }
+ return
+}
+
+func (_ *Ed25519Key) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Ed25519Key)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Ed25519Key) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ var zb0004 int
+ var zb0005 bool
+ zb0004, zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec")
+ return
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Sec.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec", "struct-from-array", "SignatureVerifier")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Sec.SK)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec", "struct-from-array", "SK")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0004)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec")
+ return
+ }
+ if zb0005 {
+ (*z).Sec = SignatureSecrets{}
+ }
+ for zb0004 > 0 {
+ zb0004--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec")
+ return
+ }
+ switch string(field) {
+ case "SignatureVerifier":
+ bts, err = (*z).Sec.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec", "SignatureVerifier")
+ return
+ }
+ case "SK":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Sec.SK)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec", "SK")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Sec")
+ return
+ }
+ }
+ }
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = Ed25519Key{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "sec":
+ var zb0006 int
+ var zb0007 bool
+ zb0006, zb0007, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Sec")
+ return
+ }
+ if zb0006 > 0 {
+ zb0006--
+ bts, err = (*z).Sec.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Sec", "struct-from-array", "SignatureVerifier")
+ return
+ }
+ }
+ if zb0006 > 0 {
+ zb0006--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Sec.SK)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "Sec", "struct-from-array", "SK")
+ return
+ }
+ }
+ if zb0006 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0006)
+ if err != nil {
+ err = msgp.WrapError(err, "Sec", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "Sec")
+ return
+ }
+ if zb0007 {
+ (*z).Sec = SignatureSecrets{}
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Sec")
+ return
+ }
+ switch string(field) {
+ case "SignatureVerifier":
+ bts, err = (*z).Sec.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Sec", "SignatureVerifier")
+ return
+ }
+ case "SK":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).Sec.SK)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "Sec", "SK")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "Sec")
+ return
+ }
+ }
+ }
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Ed25519Key) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Ed25519Key)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Ed25519Key) Msgsize() (s int) {
+ s = 1 + 4 + 1 + 18 + (*z).Sec.SignatureVerifier.Msgsize() + 3 + msgp.ArrayHeaderSize + (PrivateKeyByteLength * (msgp.ByteSize))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Ed25519Key) MsgIsZero() bool {
+ return (((*z).Sec.SignatureVerifier.MsgIsZero()) && ((*z).Sec.SK == (ed25519PrivateKey{})))
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *Ed25519PublicKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(1)
+ var zb0001Mask uint8 /* 2 bits */
+ if (*z).SignatureVerifier.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "sigVerifier"
+ o = append(o, 0xab, 0x73, 0x69, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x72)
+ o = (*z).SignatureVerifier.MarshalMsg(o)
+ }
+ }
+ return
+}
+
+func (_ *Ed25519PublicKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Ed25519PublicKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *Ed25519PublicKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SignatureVerifier")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = Ed25519PublicKey{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "sigVerifier":
+ bts, err = (*z).SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SignatureVerifier")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *Ed25519PublicKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*Ed25519PublicKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *Ed25519PublicKey) Msgsize() (s int) {
+ s = 1 + 12 + (*z).SignatureVerifier.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *Ed25519PublicKey) MsgIsZero() bool {
+ return ((*z).SignatureVerifier.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z GenericDigest) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendBytes(o, []byte(z))
+ return
+}
+
+func (_ GenericDigest) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(GenericDigest)
+ if !ok {
+ _, ok = (z).(*GenericDigest)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *GenericDigest) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 []byte
+ zb0001, bts, err = msgp.ReadBytesBytes(bts, []byte((*z)))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = GenericDigest(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *GenericDigest) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*GenericDigest)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z GenericDigest) Msgsize() (s int) {
+ s = msgp.BytesPrefixSize + len([]byte(z))
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z GenericDigest) MsgIsZero() bool {
+ return len(z) == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *HashFactory) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(1)
+ var zb0001Mask uint8 /* 2 bits */
+ if (*z).HashType == 0 {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "t"
+ o = append(o, 0xa1, 0x74)
+ o = msgp.AppendUint64(o, uint64((*z).HashType))
+ }
+ }
+ return
+}
+
+func (_ *HashFactory) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*HashFactory)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *HashFactory) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ {
+ var zb0003 uint64
+ zb0003, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HashType")
+ return
+ }
+ (*z).HashType = HashType(zb0003)
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = HashFactory{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "t":
+ {
+ var zb0004 uint64
+ zb0004, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HashType")
+ return
+ }
+ (*z).HashType = HashType(zb0004)
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *HashFactory) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*HashFactory)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *HashFactory) Msgsize() (s int) {
+ s = 1 + 2 + msgp.Uint64Size
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *HashFactory) MsgIsZero() bool {
+ return ((*z).HashType == 0)
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z HashType) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ o = msgp.AppendUint64(o, uint64(z))
+ return
+}
+
+func (_ HashType) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(HashType)
+ if !ok {
+ _, ok = (z).(*HashType)
+ }
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *HashType) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ {
+ var zb0001 uint64
+ zb0001, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ (*z) = HashType(zb0001)
+ }
+ o = bts
+ return
+}
+
+func (_ *HashType) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*HashType)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z HashType) Msgsize() (s int) {
+ s = msgp.Uint64Size
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z HashType) MsgIsZero() bool {
+ return z == 0
+}
+
+// MarshalMsg implements msgp.Marshaler
func (z *MasterDerivationKey) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
o = msgp.AppendBytes(o, (*z)[:])
@@ -1740,6 +2980,490 @@ func (z *OneTimeSignatureVerifier) MsgIsZero() bool {
}
// MarshalMsg implements msgp.Marshaler
+func (z *PackedSignatureAlgorithm) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(2)
+ var zb0001Mask uint8 /* 3 bits */
+ if (*z).DilithiumSigner.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ if (*z).Ed25519Singer.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x4
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "ds"
+ o = append(o, 0xa2, 0x64, 0x73)
+ o = (*z).DilithiumSigner.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
+ // string "edds"
+ o = append(o, 0xa4, 0x65, 0x64, 0x64, 0x73)
+ o = (*z).Ed25519Singer.MarshalMsg(o)
+ }
+ }
+ return
+}
+
+func (_ *PackedSignatureAlgorithm) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*PackedSignatureAlgorithm)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *PackedSignatureAlgorithm) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumSigner")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519Singer")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = PackedSignatureAlgorithm{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "ds":
+ bts, err = (*z).DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumSigner")
+ return
+ }
+ case "edds":
+ bts, err = (*z).Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519Singer")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *PackedSignatureAlgorithm) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*PackedSignatureAlgorithm)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *PackedSignatureAlgorithm) Msgsize() (s int) {
+ s = 1 + 3 + (*z).DilithiumSigner.Msgsize() + 5 + (*z).Ed25519Singer.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *PackedSignatureAlgorithm) MsgIsZero() bool {
+ return ((*z).DilithiumSigner.MsgIsZero()) && ((*z).Ed25519Singer.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z *PackedVerifyingKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0002Len := uint32(2)
+ var zb0002Mask uint8 /* 3 bits */
+ if (*z).DilithiumPublicKey.PublicKey == (DPublicKey{}) {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ if (*z).Ed25519PublicKey.SignatureVerifier.MsgIsZero() {
+ zb0002Len--
+ zb0002Mask |= 0x4
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if zb0002Len != 0 {
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "dpk"
+ o = append(o, 0xa3, 0x64, 0x70, 0x6b)
+ // omitempty: check for empty values
+ zb0003Len := uint32(1)
+ var zb0003Mask uint8 /* 2 bits */
+ if (*z).DilithiumPublicKey.PublicKey == (DPublicKey{}) {
+ zb0003Len--
+ zb0003Mask |= 0x2
+ }
+ // variable map header, size zb0003Len
+ o = append(o, 0x80|uint8(zb0003Len))
+ if (zb0003Mask & 0x2) == 0 { // if not empty
+ // string "k"
+ o = append(o, 0xa1, 0x6b)
+ o = msgp.AppendBytes(o, ((*z).DilithiumPublicKey.PublicKey)[:])
+ }
+ }
+ if (zb0002Mask & 0x4) == 0 { // if not empty
+ // string "edpk"
+ o = append(o, 0xa4, 0x65, 0x64, 0x70, 0x6b)
+ // omitempty: check for empty values
+ zb0004Len := uint32(1)
+ var zb0004Mask uint8 /* 2 bits */
+ if (*z).Ed25519PublicKey.SignatureVerifier.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x2
+ }
+ // variable map header, size zb0004Len
+ o = append(o, 0x80|uint8(zb0004Len))
+ if (zb0004Mask & 0x2) == 0 { // if not empty
+ // string "sigVerifier"
+ o = append(o, 0xab, 0x73, 0x69, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x72)
+ o = (*z).Ed25519PublicKey.SignatureVerifier.MarshalMsg(o)
+ }
+ }
+ }
+ return
+}
+
+func (_ *PackedVerifyingKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*PackedVerifyingKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *PackedVerifyingKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0002 int
+ var zb0003 bool
+ zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 > 0 {
+ zb0002--
+ var zb0004 int
+ var zb0005 bool
+ zb0004, zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey")
+ return
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).DilithiumPublicKey.PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey", "struct-from-array", "PublicKey")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0004)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey")
+ return
+ }
+ if zb0005 {
+ (*z).DilithiumPublicKey = DilithiumVerifier{}
+ }
+ for zb0004 > 0 {
+ zb0004--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey")
+ return
+ }
+ switch string(field) {
+ case "k":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).DilithiumPublicKey.PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey", "PublicKey")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "DilithiumPublicKey")
+ return
+ }
+ }
+ }
+ }
+ }
+ if zb0002 > 0 {
+ zb0002--
+ var zb0006 int
+ var zb0007 bool
+ zb0006, zb0007, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey")
+ return
+ }
+ if zb0006 > 0 {
+ zb0006--
+ bts, err = (*z).Ed25519PublicKey.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey", "struct-from-array", "SignatureVerifier")
+ return
+ }
+ }
+ if zb0006 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0006)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey")
+ return
+ }
+ if zb0007 {
+ (*z).Ed25519PublicKey = Ed25519PublicKey{}
+ }
+ for zb0006 > 0 {
+ zb0006--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey")
+ return
+ }
+ switch string(field) {
+ case "sigVerifier":
+ bts, err = (*z).Ed25519PublicKey.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey", "SignatureVerifier")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Ed25519PublicKey")
+ return
+ }
+ }
+ }
+ }
+ }
+ if zb0002 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0002)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0003 {
+ (*z) = PackedVerifyingKey{}
+ }
+ for zb0002 > 0 {
+ zb0002--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "dpk":
+ var zb0008 int
+ var zb0009 bool
+ zb0008, zb0009, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0008, zb0009, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey")
+ return
+ }
+ if zb0008 > 0 {
+ zb0008--
+ bts, err = msgp.ReadExactBytes(bts, ((*z).DilithiumPublicKey.PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey", "struct-from-array", "PublicKey")
+ return
+ }
+ }
+ if zb0008 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0008)
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey")
+ return
+ }
+ if zb0009 {
+ (*z).DilithiumPublicKey = DilithiumVerifier{}
+ }
+ for zb0008 > 0 {
+ zb0008--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey")
+ return
+ }
+ switch string(field) {
+ case "k":
+ bts, err = msgp.ReadExactBytes(bts, ((*z).DilithiumPublicKey.PublicKey)[:])
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey", "PublicKey")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "DilithiumPublicKey")
+ return
+ }
+ }
+ }
+ }
+ case "edpk":
+ var zb0010 int
+ var zb0011 bool
+ zb0010, zb0011, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0010, zb0011, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey")
+ return
+ }
+ if zb0010 > 0 {
+ zb0010--
+ bts, err = (*z).Ed25519PublicKey.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey", "struct-from-array", "SignatureVerifier")
+ return
+ }
+ }
+ if zb0010 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0010)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey")
+ return
+ }
+ if zb0011 {
+ (*z).Ed25519PublicKey = Ed25519PublicKey{}
+ }
+ for zb0010 > 0 {
+ zb0010--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey")
+ return
+ }
+ switch string(field) {
+ case "sigVerifier":
+ bts, err = (*z).Ed25519PublicKey.SignatureVerifier.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey", "SignatureVerifier")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "Ed25519PublicKey")
+ return
+ }
+ }
+ }
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *PackedVerifyingKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*PackedVerifyingKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *PackedVerifyingKey) Msgsize() (s int) {
+ s = 1 + 4 + 1 + 2 + msgp.ArrayHeaderSize + (cdilithium.PublicKeySize * (msgp.ByteSize)) + 5 + 1 + 12 + (*z).Ed25519PublicKey.SignatureVerifier.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *PackedVerifyingKey) MsgIsZero() bool {
+ return ((*z).DilithiumPublicKey.PublicKey == (DPublicKey{})) && ((*z).Ed25519PublicKey.SignatureVerifier.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
func (z *PrivateKey) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
o = msgp.AppendBytes(o, (*z)[:])
@@ -1896,6 +3620,293 @@ func (z *Signature) MsgIsZero() bool {
}
// MarshalMsg implements msgp.Marshaler
+func (z *SignatureAlgorithm) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(2)
+ var zb0001Mask uint8 /* 3 bits */
+ if ((*z).Pack.DilithiumSigner.MsgIsZero()) && ((*z).Pack.Ed25519Singer.MsgIsZero()) {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ if (*z).Type == 0 {
+ zb0001Len--
+ zb0001Mask |= 0x4
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "keys"
+ o = append(o, 0xa4, 0x6b, 0x65, 0x79, 0x73)
+ // omitempty: check for empty values
+ zb0002Len := uint32(2)
+ var zb0002Mask uint8 /* 3 bits */
+ if (*z).Pack.DilithiumSigner.MsgIsZero() {
+ zb0002Len--
+ zb0002Mask |= 0x2
+ }
+ if (*z).Pack.Ed25519Singer.MsgIsZero() {
+ zb0002Len--
+ zb0002Mask |= 0x4
+ }
+ // variable map header, size zb0002Len
+ o = append(o, 0x80|uint8(zb0002Len))
+ if (zb0002Mask & 0x2) == 0 { // if not empty
+ // string "ds"
+ o = append(o, 0xa2, 0x64, 0x73)
+ o = (*z).Pack.DilithiumSigner.MarshalMsg(o)
+ }
+ if (zb0002Mask & 0x4) == 0 { // if not empty
+ // string "edds"
+ o = append(o, 0xa4, 0x65, 0x64, 0x64, 0x73)
+ o = (*z).Pack.Ed25519Singer.MarshalMsg(o)
+ }
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
+ // string "sigType"
+ o = append(o, 0xa7, 0x73, 0x69, 0x67, 0x54, 0x79, 0x70, 0x65)
+ o = msgp.AppendUint64(o, uint64((*z).Type))
+ }
+ }
+ return
+}
+
+func (_ *SignatureAlgorithm) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*SignatureAlgorithm)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *SignatureAlgorithm) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ {
+ var zb0003 uint64
+ zb0003, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Type")
+ return
+ }
+ (*z).Type = AlgorithmType(zb0003)
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ var zb0004 int
+ var zb0005 bool
+ zb0004, zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack")
+ return
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Pack.DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack", "struct-from-array", "DilithiumSigner")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Pack.Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack", "struct-from-array", "Ed25519Singer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0004)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack")
+ return
+ }
+ if zb0005 {
+ (*z).Pack = PackedSignatureAlgorithm{}
+ }
+ for zb0004 > 0 {
+ zb0004--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack")
+ return
+ }
+ switch string(field) {
+ case "ds":
+ bts, err = (*z).Pack.DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack", "DilithiumSigner")
+ return
+ }
+ case "edds":
+ bts, err = (*z).Pack.Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack", "Ed25519Singer")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack")
+ return
+ }
+ }
+ }
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = SignatureAlgorithm{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "sigType":
+ {
+ var zb0006 uint64
+ zb0006, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Type")
+ return
+ }
+ (*z).Type = AlgorithmType(zb0006)
+ }
+ case "keys":
+ var zb0007 int
+ var zb0008 bool
+ zb0007, zb0008, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0007, zb0008, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack")
+ return
+ }
+ if zb0007 > 0 {
+ zb0007--
+ bts, err = (*z).Pack.DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack", "struct-from-array", "DilithiumSigner")
+ return
+ }
+ }
+ if zb0007 > 0 {
+ zb0007--
+ bts, err = (*z).Pack.Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack", "struct-from-array", "Ed25519Singer")
+ return
+ }
+ }
+ if zb0007 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0007)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack", "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err, "Pack")
+ return
+ }
+ if zb0008 {
+ (*z).Pack = PackedSignatureAlgorithm{}
+ }
+ for zb0007 > 0 {
+ zb0007--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack")
+ return
+ }
+ switch string(field) {
+ case "ds":
+ bts, err = (*z).Pack.DilithiumSigner.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack", "DilithiumSigner")
+ return
+ }
+ case "edds":
+ bts, err = (*z).Pack.Ed25519Singer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack", "Ed25519Singer")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err, "Pack")
+ return
+ }
+ }
+ }
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *SignatureAlgorithm) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*SignatureAlgorithm)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *SignatureAlgorithm) Msgsize() (s int) {
+ s = 1 + 8 + msgp.Uint64Size + 5 + 1 + 3 + (*z).Pack.DilithiumSigner.Msgsize() + 5 + (*z).Pack.Ed25519Singer.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *SignatureAlgorithm) MsgIsZero() bool {
+ return ((*z).Type == 0) && (((*z).Pack.DilithiumSigner.MsgIsZero()) && ((*z).Pack.Ed25519Singer.MsgIsZero()))
+}
+
+// MarshalMsg implements msgp.Marshaler
func (z *SignatureSecrets) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// map header, size 2
@@ -2118,6 +4129,143 @@ func (z *VRFSecrets) MsgIsZero() bool {
}
// MarshalMsg implements msgp.Marshaler
+func (z *VerifyingKey) MarshalMsg(b []byte) (o []byte) {
+ o = msgp.Require(b, z.Msgsize())
+ // omitempty: check for empty values
+ zb0001Len := uint32(2)
+ var zb0001Mask uint8 /* 3 bits */
+ if (*z).Pack.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x2
+ }
+ if (*z).Type == 0 {
+ zb0001Len--
+ zb0001Mask |= 0x4
+ }
+ // variable map header, size zb0001Len
+ o = append(o, 0x80|uint8(zb0001Len))
+ if zb0001Len != 0 {
+ if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "pks"
+ o = append(o, 0xa3, 0x70, 0x6b, 0x73)
+ o = (*z).Pack.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
+ // string "type"
+ o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
+ o = msgp.AppendUint64(o, uint64((*z).Type))
+ }
+ }
+ return
+}
+
+func (_ *VerifyingKey) CanMarshalMsg(z interface{}) bool {
+ _, ok := (z).(*VerifyingKey)
+ return ok
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *VerifyingKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 int
+ var zb0002 bool
+ zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if _, ok := err.(msgp.TypeError); ok {
+ zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 > 0 {
+ zb0001--
+ {
+ var zb0003 uint64
+ zb0003, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Type")
+ return
+ }
+ (*z).Type = AlgorithmType(zb0003)
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
+ bts, err = (*z).Pack.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Pack")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0001)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array")
+ return
+ }
+ }
+ } else {
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0002 {
+ (*z) = VerifyingKey{}
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch string(field) {
+ case "type":
+ {
+ var zb0004 uint64
+ zb0004, bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Type")
+ return
+ }
+ (*z).Type = AlgorithmType(zb0004)
+ }
+ case "pks":
+ bts, err = (*z).Pack.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Pack")
+ return
+ }
+ default:
+ err = msgp.ErrNoField(string(field))
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+func (_ *VerifyingKey) CanUnmarshalMsg(z interface{}) bool {
+ _, ok := (z).(*VerifyingKey)
+ return ok
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z *VerifyingKey) Msgsize() (s int) {
+ s = 1 + 5 + msgp.Uint64Size + 4 + (*z).Pack.Msgsize()
+ return
+}
+
+// MsgIsZero returns whether this is a zero value
+func (z *VerifyingKey) MsgIsZero() bool {
+ return ((*z).Type == 0) && ((*z).Pack.MsgIsZero())
+}
+
+// MarshalMsg implements msgp.Marshaler
func (z *VrfOutput) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
o = msgp.AppendBytes(o, (*z)[:])
diff --git a/crypto/msgp_gen_test.go b/crypto/msgp_gen_test.go
index 8a80c972f..dd87d38f1 100644
--- a/crypto/msgp_gen_test.go
+++ b/crypto/msgp_gen_test.go
@@ -12,6 +12,126 @@ import (
"github.com/algorand/msgp/msgp"
)
+func TestMarshalUnmarshalDPublicKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := DPublicKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingDPublicKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &DPublicKey{})
+}
+
+func BenchmarkMarshalMsgDPublicKey(b *testing.B) {
+ v := DPublicKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgDPublicKey(b *testing.B) {
+ v := DPublicKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalDPublicKey(b *testing.B) {
+ v := DPublicKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalDSecretKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := DSecretKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingDSecretKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &DSecretKey{})
+}
+
+func BenchmarkMarshalMsgDSecretKey(b *testing.B) {
+ v := DSecretKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgDSecretKey(b *testing.B) {
+ v := DSecretKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalDSecretKey(b *testing.B) {
+ v := DSecretKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
func TestMarshalUnmarshalDigest(t *testing.T) {
partitiontest.PartitionTest(t)
v := Digest{}
@@ -72,6 +192,306 @@ func BenchmarkUnmarshalDigest(b *testing.B) {
}
}
+func TestMarshalUnmarshalDilithiumSigner(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := DilithiumSigner{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingDilithiumSigner(t *testing.T) {
+ protocol.RunEncodingTest(t, &DilithiumSigner{})
+}
+
+func BenchmarkMarshalMsgDilithiumSigner(b *testing.B) {
+ v := DilithiumSigner{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgDilithiumSigner(b *testing.B) {
+ v := DilithiumSigner{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalDilithiumSigner(b *testing.B) {
+ v := DilithiumSigner{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalDilithiumVerifier(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := DilithiumVerifier{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingDilithiumVerifier(t *testing.T) {
+ protocol.RunEncodingTest(t, &DilithiumVerifier{})
+}
+
+func BenchmarkMarshalMsgDilithiumVerifier(b *testing.B) {
+ v := DilithiumVerifier{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgDilithiumVerifier(b *testing.B) {
+ v := DilithiumVerifier{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalDilithiumVerifier(b *testing.B) {
+ v := DilithiumVerifier{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalEd25519Key(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Ed25519Key{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingEd25519Key(t *testing.T) {
+ protocol.RunEncodingTest(t, &Ed25519Key{})
+}
+
+func BenchmarkMarshalMsgEd25519Key(b *testing.B) {
+ v := Ed25519Key{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgEd25519Key(b *testing.B) {
+ v := Ed25519Key{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalEd25519Key(b *testing.B) {
+ v := Ed25519Key{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalEd25519PublicKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := Ed25519PublicKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingEd25519PublicKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &Ed25519PublicKey{})
+}
+
+func BenchmarkMarshalMsgEd25519PublicKey(b *testing.B) {
+ v := Ed25519PublicKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgEd25519PublicKey(b *testing.B) {
+ v := Ed25519PublicKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalEd25519PublicKey(b *testing.B) {
+ v := Ed25519PublicKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalHashFactory(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := HashFactory{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingHashFactory(t *testing.T) {
+ protocol.RunEncodingTest(t, &HashFactory{})
+}
+
+func BenchmarkMarshalMsgHashFactory(b *testing.B) {
+ v := HashFactory{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgHashFactory(b *testing.B) {
+ v := HashFactory{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalHashFactory(b *testing.B) {
+ v := HashFactory{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
func TestMarshalUnmarshalMasterDerivationKey(t *testing.T) {
partitiontest.PartitionTest(t)
v := MasterDerivationKey{}
@@ -612,6 +1032,126 @@ func BenchmarkUnmarshalOneTimeSignatureVerifier(b *testing.B) {
}
}
+func TestMarshalUnmarshalPackedSignatureAlgorithm(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := PackedSignatureAlgorithm{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingPackedSignatureAlgorithm(t *testing.T) {
+ protocol.RunEncodingTest(t, &PackedSignatureAlgorithm{})
+}
+
+func BenchmarkMarshalMsgPackedSignatureAlgorithm(b *testing.B) {
+ v := PackedSignatureAlgorithm{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgPackedSignatureAlgorithm(b *testing.B) {
+ v := PackedSignatureAlgorithm{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalPackedSignatureAlgorithm(b *testing.B) {
+ v := PackedSignatureAlgorithm{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestMarshalUnmarshalPackedVerifyingKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := PackedVerifyingKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingPackedVerifyingKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &PackedVerifyingKey{})
+}
+
+func BenchmarkMarshalMsgPackedVerifyingKey(b *testing.B) {
+ v := PackedVerifyingKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgPackedVerifyingKey(b *testing.B) {
+ v := PackedVerifyingKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalPackedVerifyingKey(b *testing.B) {
+ v := PackedVerifyingKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
func TestMarshalUnmarshalPrivateKey(t *testing.T) {
partitiontest.PartitionTest(t)
v := PrivateKey{}
@@ -852,6 +1392,66 @@ func BenchmarkUnmarshalSignature(b *testing.B) {
}
}
+func TestMarshalUnmarshalSignatureAlgorithm(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := SignatureAlgorithm{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingSignatureAlgorithm(t *testing.T) {
+ protocol.RunEncodingTest(t, &SignatureAlgorithm{})
+}
+
+func BenchmarkMarshalMsgSignatureAlgorithm(b *testing.B) {
+ v := SignatureAlgorithm{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgSignatureAlgorithm(b *testing.B) {
+ v := SignatureAlgorithm{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalSignatureAlgorithm(b *testing.B) {
+ v := SignatureAlgorithm{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
func TestMarshalUnmarshalSignatureSecrets(t *testing.T) {
partitiontest.PartitionTest(t)
v := SignatureSecrets{}
@@ -972,6 +1572,66 @@ func BenchmarkUnmarshalVRFSecrets(b *testing.B) {
}
}
+func TestMarshalUnmarshalVerifyingKey(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ v := VerifyingKey{}
+ bts := v.MarshalMsg(nil)
+ left, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
+ }
+
+ left, err = msgp.Skip(bts)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(left) > 0 {
+ t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
+ }
+}
+
+func TestRandomizedEncodingVerifyingKey(t *testing.T) {
+ protocol.RunEncodingTest(t, &VerifyingKey{})
+}
+
+func BenchmarkMarshalMsgVerifyingKey(b *testing.B) {
+ v := VerifyingKey{}
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ v.MarshalMsg(nil)
+ }
+}
+
+func BenchmarkAppendMsgVerifyingKey(b *testing.B) {
+ v := VerifyingKey{}
+ bts := make([]byte, 0, v.Msgsize())
+ bts = v.MarshalMsg(bts[0:0])
+ b.SetBytes(int64(len(bts)))
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ bts = v.MarshalMsg(bts[0:0])
+ }
+}
+
+func BenchmarkUnmarshalVerifyingKey(b *testing.B) {
+ v := VerifyingKey{}
+ bts := v.MarshalMsg(nil)
+ b.ReportAllocs()
+ b.SetBytes(int64(len(bts)))
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := v.UnmarshalMsg(bts)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
func TestMarshalUnmarshalVrfOutput(t *testing.T) {
partitiontest.PartitionTest(t)
v := VrfOutput{}
diff --git a/crypto/onetimesig.go b/crypto/onetimesig.go
index 435e85660..092fd1b86 100644
--- a/crypto/onetimesig.go
+++ b/crypto/onetimesig.go
@@ -213,7 +213,7 @@ func GenerateOneTimeSignatureSecretsRNG(startBatch uint64, numBatches uint64, rn
batchnum := startBatch + i
newid := OneTimeSignatureSubkeyBatchID{SubKeyPK: pk, Batch: batchnum}
- newsig := ed25519Sign(ephemeralSec, hashRep(newid))
+ newsig := ed25519Sign(ephemeralSec, HashRep(newid))
subkeys[i] = ephemeralSubkey{
PK: pk,
@@ -255,7 +255,7 @@ func (s *OneTimeSignatureSecrets) Sign(id OneTimeSignatureIdentifier, message Ha
// Check if we already have a partial batch of subkeys.
if id.Batch+1 == s.FirstBatch && id.Offset >= s.FirstOffset && id.Offset-s.FirstOffset < uint64(len(s.Offsets)) {
offidx := id.Offset - s.FirstOffset
- sig := ed25519Sign(s.Offsets[offidx].SK, hashRep(message))
+ sig := ed25519Sign(s.Offsets[offidx].SK, HashRep(message))
return OneTimeSignature{
Sig: sig,
PK: s.Offsets[offidx].PK,
@@ -270,7 +270,7 @@ func (s *OneTimeSignatureSecrets) Sign(id OneTimeSignatureIdentifier, message Ha
// Since we have not yet broken out this batch into per-offset keys,
// generate a fresh subkey right away, sign it, and use it.
pk, sk := ed25519GenerateKeyRNG(s.getRNG())
- sig := ed25519Sign(sk, hashRep(message))
+ sig := ed25519Sign(sk, HashRep(message))
batchidx := id.Batch - s.FirstBatch
pksig := s.Batches[batchidx].PKSigNew
@@ -283,7 +283,7 @@ func (s *OneTimeSignatureSecrets) Sign(id OneTimeSignatureIdentifier, message Ha
return OneTimeSignature{
Sig: sig,
PK: pk,
- PK1Sig: ed25519Sign(s.Batches[batchidx].SK, hashRep(pk1id)),
+ PK1Sig: ed25519Sign(s.Batches[batchidx].SK, HashRep(pk1id)),
PK2: s.Batches[batchidx].PK,
PK2Sig: pksig,
}
@@ -321,13 +321,13 @@ func (v OneTimeSignatureVerifier) Verify(id OneTimeSignatureIdentifier, message
Batch: id.Batch,
}
- if !ed25519Verify(ed25519PublicKey(v), hashRep(batchID), sig.PK2Sig) {
+ if !ed25519Verify(ed25519PublicKey(v), HashRep(batchID), sig.PK2Sig) {
return false
}
- if !ed25519Verify(batchID.SubKeyPK, hashRep(offsetID), sig.PK1Sig) {
+ if !ed25519Verify(batchID.SubKeyPK, HashRep(offsetID), sig.PK1Sig) {
return false
}
- if !ed25519Verify(offsetID.SubKeyPK, hashRep(message), sig.Sig) {
+ if !ed25519Verify(offsetID.SubKeyPK, HashRep(message), sig.Sig) {
return false
}
return true
@@ -393,7 +393,7 @@ func (s *OneTimeSignatureSecrets) DeleteBeforeFineGrained(current OneTimeSignatu
s.FirstOffset = current.Offset
for off := current.Offset; off < numKeysPerBatch; off++ {
pk, sk := ed25519GenerateKeyRNG(s.getRNG())
- pksig := ed25519Sign(s.Batches[0].SK, hashRep(OneTimeSignatureSubkeyOffsetID{
+ pksig := ed25519Sign(s.Batches[0].SK, HashRep(OneTimeSignatureSubkeyOffsetID{
SubKeyPK: pk,
Batch: current.Batch,
Offset: off,
diff --git a/crypto/sig_abstractions.go b/crypto/sig_abstractions.go
new file mode 100644
index 000000000..8ed675ed8
--- /dev/null
+++ b/crypto/sig_abstractions.go
@@ -0,0 +1,166 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package crypto
+
+import (
+ "errors"
+ "fmt"
+
+ "github.com/algorand/go-algorand/protocol"
+)
+
+type (
+ //ByteSignature using unspecified bound.
+ //msgp:allocbound ByteSignature
+ ByteSignature []byte
+
+ // AlgorithmType enum type for signing algorithms
+ AlgorithmType uint64
+)
+
+// all AlgorithmType enums
+const (
+ minAlgorithmType AlgorithmType = iota
+
+ DilithiumType
+ Ed25519Type
+
+ maxAlgorithmType
+)
+
+// Signer interface represents the possible operations that can be done with a signing key.
+type Signer interface {
+ Sign(message Hashable) ByteSignature
+ SignBytes(message []byte) ByteSignature
+ GetVerifyingKey() *VerifyingKey
+}
+
+// ErrBadSignature represents a bad signature
+var ErrBadSignature = fmt.Errorf("invalid signature")
+
+// Verifier interface represents any algorithm that can verify signatures for a specific signing scheme.
+type Verifier interface {
+ // Verify and VerifyBytes returns error on bad signature, and any other problem.
+ Verify(message Hashable, sig ByteSignature) error
+ VerifyBytes(message []byte, sig ByteSignature) error
+}
+
+// SignatureAlgorithm holds a Signer, and the type of algorithm the Signer conforms with.
+// to add a key - verify that PackedSignatureAlgorithm's function (getSigner) returns your key.
+type SignatureAlgorithm struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ Type AlgorithmType `codec:"sigType"`
+ Pack PackedSignatureAlgorithm `codec:"keys"`
+}
+
+// VerifyingKey is an abstraction of a key store of verifying keys.
+// it can return the correct key according to the underlying algorithm.
+// Implements Hashable too.
+//
+// NOTE: The VerifyingKey key might not be a valid key if a malicious client sent it over the network
+// make certain it is valid.
+type VerifyingKey struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ Type AlgorithmType `codec:"type"`
+ Pack PackedVerifyingKey `codec:"pks"`
+}
+
+// ToBeHashed makes it easier to hash the VeryfyingKey struct.
+func (z *VerifyingKey) ToBeHashed() (protocol.HashID, []byte) {
+ return protocol.VerifyingKey, protocol.Encode(z)
+}
+
+// GetSigner fetches the Signer type that is stored inside this SignatureAlgorithm.
+func (z *SignatureAlgorithm) GetSigner() (Signer, error) {
+ return z.Pack.getSigner(z.Type)
+}
+
+// GetVerifier fetches the Verifier type that is stored inside this VerifyingKey.
+func (z *VerifyingKey) GetVerifier() (Verifier, error) {
+ return z.Pack.getVerifier(z.Type)
+}
+
+// PackedVerifyingKey is a key store. Allows for easy marshal/unmarshal.
+type PackedVerifyingKey struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ DilithiumPublicKey DilithiumVerifier `codec:"dpk"`
+ Ed25519PublicKey Ed25519PublicKey `codec:"edpk"`
+}
+
+var errUnknownVerifier = errors.New("could not find stored Verifier")
+
+func (p *PackedVerifyingKey) getVerifier(t AlgorithmType) (Verifier, error) {
+ switch t {
+ case DilithiumType:
+ return &p.DilithiumPublicKey, nil
+ case Ed25519Type:
+ return &p.Ed25519PublicKey, nil
+ default:
+ return nil, errUnknownVerifier
+ }
+}
+
+// PackedSignatureAlgorithm helps marshal SignatureAlgorithm
+type PackedSignatureAlgorithm struct {
+ _struct struct{} `codec:",omitempty,omitemptyarray"`
+
+ DilithiumSigner DilithiumSigner `codec:"ds"`
+ Ed25519Singer Ed25519Key `codec:"edds"`
+}
+
+var errUnknownSigner = errors.New("could not find stored signer")
+
+func (p *PackedSignatureAlgorithm) getSigner(t AlgorithmType) (Signer, error) {
+ switch t {
+ case DilithiumType:
+ return &p.DilithiumSigner, nil
+ case Ed25519Type:
+ return &p.Ed25519Singer, nil
+ default:
+ return nil, errUnknownSigner
+ }
+}
+
+var errNonExistingSignatureAlgorithmType = errors.New("signing algorithm type does not exist")
+
+// NewSigner receives a type of signing algorithm and generates keys.
+func NewSigner(t AlgorithmType) (*SignatureAlgorithm, error) {
+ var p PackedSignatureAlgorithm
+ switch t {
+ case DilithiumType:
+ signer := NewDilithiumSigner().(*DilithiumSigner)
+ p = PackedSignatureAlgorithm{
+ DilithiumSigner: *signer,
+ }
+ case Ed25519Type:
+ var seed Seed
+ SystemRNG.RandBytes(seed[:])
+ key := GenerateEd25519Key(seed)
+ p = PackedSignatureAlgorithm{
+ Ed25519Singer: *key,
+ }
+ default:
+ return nil, errNonExistingSignatureAlgorithmType
+ }
+ return &SignatureAlgorithm{
+ Type: t,
+ Pack: p,
+ }, nil
+}
diff --git a/crypto/util.go b/crypto/util.go
index 568570928..e4db5a8f5 100644
--- a/crypto/util.go
+++ b/crypto/util.go
@@ -34,7 +34,8 @@ type Hashable interface {
ToBeHashed() (protocol.HashID, []byte)
}
-func hashRep(h Hashable) []byte {
+// HashRep appends the correct hashid to the before the message to be hashed.
+func HashRep(h Hashable) []byte {
hashid, data := h.ToBeHashed()
return append([]byte(hashid), data...)
}
@@ -45,6 +46,16 @@ const DigestSize = sha512.Size256
// Digest represents a 32-byte value holding the 256-bit Hash digest.
type Digest [DigestSize]byte
+// To32Byte implements merklearray.TreeDigest
+func (d Digest) To32Byte() [32]byte {
+ return d
+}
+
+// ToSlice implements merklearray.TreeDigest
+func (d Digest) ToSlice() []byte {
+ return d[:]
+}
+
// String returns the digest in a human-readable Base32 string
func (d Digest) String() string {
return base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(d[:])
@@ -81,7 +92,7 @@ func Hash(data []byte) Digest {
// HashObj computes a hash of a Hashable object and its type
func HashObj(h Hashable) Digest {
- return Hash(hashRep(h))
+ return Hash(HashRep(h))
}
// NewHash returns a sha512-256 object to do the same operation as Hash()
diff --git a/crypto/vrf.go b/crypto/vrf.go
index 36a6e8270..ceee25ce8 100644
--- a/crypto/vrf.go
+++ b/crypto/vrf.go
@@ -111,7 +111,7 @@ func (sk VrfPrivkey) proveBytes(msg []byte) (proof VrfProof, ok bool) {
// Prove constructs a VRF Proof for a given Hashable.
// ok will be false if the private key is malformed.
func (sk VrfPrivkey) Prove(message Hashable) (proof VrfProof, ok bool) {
- return sk.proveBytes(hashRep(message))
+ return sk.proveBytes(HashRep(message))
}
// Hash converts a VRF proof to a VRF output without verifying the proof.
@@ -137,5 +137,5 @@ func (pk VrfPubkey) verifyBytes(proof VrfProof, msg []byte) (bool, VrfOutput) {
// However, given a public key and message, all valid proofs will yield the same output.
// Moreover, the output is indistinguishable from random to anyone without the proof or the secret key.
func (pk VrfPubkey) Verify(p VrfProof, message Hashable) (bool, VrfOutput) {
- return pk.verifyBytes(p, hashRep(message))
+ return pk.verifyBytes(p, HashRep(message))
}
diff --git a/daemon/algod/api/server/v1/handlers/handlers.go b/daemon/algod/api/server/v1/handlers/handlers.go
index 9d2d34934..a48bc42a4 100644
--- a/daemon/algod/api/server/v1/handlers/handlers.go
+++ b/daemon/algod/api/server/v1/handlers/handlers.go
@@ -508,7 +508,7 @@ func blockEncode(b bookkeeping.Block, c agreement.Certificate) (v1.Block, error)
CompactCertNextRound: uint64(b.CompactCert[protocol.CompactCertBasic].CompactCertNextRound),
}
- if !b.CompactCert[protocol.CompactCertBasic].CompactCertVoters.IsZero() {
+ if !b.CompactCert[protocol.CompactCertBasic].CompactCertVoters.IsEmpty() {
voters := b.CompactCert[protocol.CompactCertBasic].CompactCertVoters
block.CompactCertVoters = voters[:]
}
diff --git a/daemon/algod/api/server/v2/handlers.go b/daemon/algod/api/server/v2/handlers.go
index 44a32fa2d..6b2c02235 100644
--- a/daemon/algod/api/server/v2/handlers.go
+++ b/daemon/algod/api/server/v2/handlers.go
@@ -221,7 +221,7 @@ func (v2 *Handlers) GetProof(ctx echo.Context, round uint64, txid string, params
}
proofconcat := make([]byte, 0)
- for _, proofelem := range proof {
+ for _, proofelem := range proof.Path {
proofconcat = append(proofconcat, proofelem[:]...)
}
diff --git a/data/account/account.go b/data/account/account.go
index f9cd26944..008919402 100644
--- a/data/account/account.go
+++ b/data/account/account.go
@@ -22,6 +22,8 @@ import (
"database/sql"
"fmt"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/logging"
@@ -135,7 +137,7 @@ func (root Root) Address() basics.Address {
// RestoreParticipation restores a Participation from a database
// handle.
func RestoreParticipation(store db.Accessor) (acc PersistedParticipation, err error) {
- var rawParent, rawVRF, rawVoting []byte
+ var rawParent, rawVRF, rawVoting, rawBlockProof []byte
err = Migrate(store)
if err != nil {
@@ -153,8 +155,9 @@ func RestoreParticipation(store db.Accessor) (acc PersistedParticipation, err er
logging.Base().Infof("RestoreParticipation: state not found (n = %v)", nrows)
}
- row = tx.QueryRow("select parent, vrf, voting, firstValid, lastValid, keyDilution from ParticipationAccount")
- err = row.Scan(&rawParent, &rawVRF, &rawVoting, &acc.FirstValid, &acc.LastValid, &acc.KeyDilution)
+ row = tx.QueryRow("select parent, vrf, voting, blockProof, firstValid, lastValid, keyDilution from ParticipationAccount")
+
+ err = row.Scan(&rawParent, &rawVRF, &rawVoting, &rawBlockProof, &acc.FirstValid, &acc.LastValid, &acc.KeyDilution)
if err != nil {
return fmt.Errorf("RestoreParticipation: could not read account raw data: %v", err)
}
@@ -166,6 +169,8 @@ func RestoreParticipation(store db.Accessor) (acc PersistedParticipation, err er
return PersistedParticipation{}, err
}
+ acc.Store = store
+
acc.VRF = &crypto.VRFSecrets{}
err = protocol.Decode(rawVRF, acc.VRF)
if err != nil {
@@ -178,6 +183,12 @@ func RestoreParticipation(store db.Accessor) (acc PersistedParticipation, err er
return PersistedParticipation{}, err
}
- acc.Store = store
+ if len(rawBlockProof) == 0 {
+ return acc, nil
+ }
+ acc.BlockProof = &merklekeystore.Signer{}
+ if err = protocol.Decode(rawBlockProof, acc.BlockProof); err != nil {
+ return PersistedParticipation{}, err
+ }
return acc, nil
}
diff --git a/data/account/partInstall.go b/data/account/partInstall.go
index 1883f68aa..53089bd2f 100644
--- a/data/account/partInstall.go
+++ b/data/account/partInstall.go
@@ -25,7 +25,7 @@ import (
const PartTableSchemaName = "parttable"
// PartTableSchemaVersion is the latest version of the PartTable schema
-const PartTableSchemaVersion = 2
+const PartTableSchemaVersion = 3
// ErrUnsupportedSchema is the error returned when the PartTable schema version is wrong.
var ErrUnsupportedSchema = fmt.Errorf("unsupported participation file schema version (expected %d)", PartTableSchemaVersion)
@@ -36,8 +36,10 @@ func partInstallDatabase(tx *sql.Tx) error {
_, err = tx.Exec(`CREATE TABLE ParticipationAccount (
parent BLOB,
- vrf BLOB, --* msgpack encoding of ParticipationAccount.vrf
- voting BLOB, --* msgpack encoding of ParticipationAccount.voting
+ --* participation keys
+ vrf BLOB, --* msgpack encoding of ParticipationAccount.vrf
+ voting BLOB, --* msgpack encoding of ParticipationAccount.voting
+ blockProof BLOB, --* msgpack encoding of ParticipationAccount.BlockProof
firstValid INTEGER,
lastValid INTEGER,
@@ -78,14 +80,14 @@ func partMigrate(tx *sql.Tx) (err error) {
var version int
err = rows.Scan(&tableName, &version)
if err != nil {
- return
+ return err
}
versions[tableName] = version
}
err = rows.Err()
if err != nil {
- return
+ return err
}
partVersion, has := versions[PartTableSchemaName]
@@ -93,22 +95,43 @@ func partMigrate(tx *sql.Tx) (err error) {
return ErrUnsupportedSchema
}
+ partVersion, err = updateDB(tx, partVersion)
+ if err != nil {
+ return err
+ }
+
+ if partVersion != PartTableSchemaVersion {
+ return ErrUnsupportedSchema
+ }
+
+ return nil
+}
+
+func updateDB(tx *sql.Tx, partVersion int) (int, error) {
if partVersion == 1 {
- _, err = tx.Exec("ALTER TABLE ParticipationAccount ADD keyDilution INTEGER NOT NULL DEFAULT 0")
+ _, err := tx.Exec("ALTER TABLE ParticipationAccount ADD keyDilution INTEGER NOT NULL DEFAULT 0")
if err != nil {
- return
+ return 0, err
}
partVersion = 2
_, err = tx.Exec("UPDATE schema SET version=? WHERE tablename=?", partVersion, PartTableSchemaName)
if err != nil {
- return
+ return 0, err
}
}
- if partVersion != PartTableSchemaVersion {
- return ErrUnsupportedSchema
- }
+ if partVersion == 2 {
+ _, err := tx.Exec("ALTER TABLE ParticipationAccount ADD blockProof BLOB")
+ if err != nil {
+ return 0, err
+ }
- return
+ partVersion = 3
+ _, err = tx.Exec("UPDATE schema SET version=? WHERE tablename=?", partVersion, PartTableSchemaName)
+ if err != nil {
+ return 0, err
+ }
+ }
+ return partVersion, nil
}
diff --git a/data/account/participation.go b/data/account/participation.go
index 269163c99..aa750839c 100644
--- a/data/account/participation.go
+++ b/data/account/participation.go
@@ -23,6 +23,7 @@ import (
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/transactions"
"github.com/algorand/go-algorand/logging"
@@ -46,6 +47,8 @@ type Participation struct {
VRF *crypto.VRFSecrets
Voting *crypto.OneTimeSignatureSecrets
+ // BlockProof is used to sign compact certificates. might be nil
+ BlockProof *merklekeystore.Signer
// The first and last rounds for which this account is valid, respectively.
//
@@ -105,8 +108,14 @@ func (part Participation) VotingSigner() crypto.OneTimeSigner {
}
}
+// BlockProofSigner returns the key used to sign on Compact Certificates.
+// might return nil!
+func (part Participation) BlockProofSigner() *merklekeystore.Signer {
+ return part.BlockProof
+}
+
// GenerateRegistrationTransaction returns a transaction object for registering a Participation with its parent.
-func (part Participation) GenerateRegistrationTransaction(fee basics.MicroAlgos, txnFirstValid, txnLastValid basics.Round, leaseBytes [32]byte) transactions.Transaction {
+func (part Participation) GenerateRegistrationTransaction(fee basics.MicroAlgos, txnFirstValid, txnLastValid basics.Round, leaseBytes [32]byte, cparams config.ConsensusParams) transactions.Transaction {
t := transactions.Transaction{
Type: protocol.KeyRegistrationTx,
Header: transactions.Header{
@@ -121,6 +130,11 @@ func (part Participation) GenerateRegistrationTransaction(fee basics.MicroAlgos,
SelectionPK: part.VRF.PK,
},
}
+ if cert := part.BlockProofSigner(); cert != nil {
+ if cparams.EnableBlockProofKeyregCheck {
+ t.KeyregTxnFields.BlockProofPK = *(cert.GetVerifier())
+ }
+ }
t.KeyregTxnFields.VoteFirst = part.FirstValid
t.KeyregTxnFields.VoteLast = part.LastValid
t.KeyregTxnFields.VoteKeyDilution = part.KeyDilution
@@ -176,15 +190,25 @@ func FillDBWithParticipationKeys(store db.Accessor, address basics.Address, firs
// Generate them
v := crypto.GenerateOneTimeSignatureSecrets(firstID.Batch, numBatches)
- // Also generate a new VRF key, which lives in the participation keys db
+ // Generate a new VRF key, which lives in the participation keys db
vrf := crypto.GenerateVRFSecrets()
+ // TODO change this
+ compactCertRound := config.Consensus[protocol.ConsensusFuture].CompactCertRounds
+
+ // Generate a new key which signs the compact certificates
+ blockProof, err := merklekeystore.New(uint64(firstValid), uint64(lastValid), compactCertRound, crypto.Ed25519Type)
+ if err != nil {
+ return PersistedParticipation{}, err
+ }
+
// Construct the Participation containing these keys to be persisted
part = PersistedParticipation{
Participation: Participation{
Parent: address,
VRF: vrf,
Voting: v,
+ BlockProof: blockProof,
FirstValid: firstValid,
LastValid: lastValid,
KeyDilution: keyDilution,
@@ -201,6 +225,7 @@ func (part PersistedParticipation) Persist() error {
rawVRF := protocol.Encode(part.VRF)
voting := part.Voting.Snapshot()
rawVoting := protocol.Encode(&voting)
+ rawbBlockProof := protocol.Encode(part.BlockProof)
err := part.Store.Atomic(func(ctx context.Context, tx *sql.Tx) error {
err := partInstallDatabase(tx)
@@ -208,8 +233,8 @@ func (part PersistedParticipation) Persist() error {
return fmt.Errorf("failed to install database: %w", err)
}
- _, err = tx.Exec("INSERT INTO ParticipationAccount (parent, vrf, voting, firstValid, lastValid, keyDilution) VALUES (?, ?, ?, ?, ?, ?)",
- part.Parent[:], rawVRF, rawVoting, part.FirstValid, part.LastValid, part.KeyDilution)
+ _, err = tx.Exec("INSERT INTO ParticipationAccount (parent, vrf, voting, blockProof, firstValid, lastValid, keyDilution) VALUES (?, ?, ?, ?, ?, ?,?)",
+ part.Parent[:], rawVRF, rawVoting, rawbBlockProof, part.FirstValid, part.LastValid, part.KeyDilution)
if err != nil {
return fmt.Errorf("failed to insert account: %w", err)
}
diff --git a/data/account/participation_test.go b/data/account/participation_test.go
index b92929b36..2431a8cbe 100644
--- a/data/account/participation_test.go
+++ b/data/account/participation_test.go
@@ -19,9 +19,14 @@ package account
import (
"context"
"database/sql"
+ "fmt"
"os"
+ "strconv"
+ "strings"
"testing"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/stretchr/testify/require"
"github.com/algorand/go-algorand/config"
@@ -32,21 +37,20 @@ import (
"github.com/algorand/go-algorand/util/db"
)
+var partableColumnNames = [...]string{"parent", "vrf", "voting", "blockProof", "firstValid", "lastValid", "keyDilution"}
+
func TestParticipation_NewDB(t *testing.T) {
partitiontest.PartitionTest(t)
a := require.New(t)
- rootDB, err := db.MakeAccessor(t.Name(), false, true)
- a.NoError(err)
- a.NotNil(rootDB)
- root, err := GenerateRoot(rootDB)
+ _, rootDB, partDB, err := setupParticipationKey(t, a)
a.NoError(err)
- a.NotNil(root)
+ closeDBS(rootDB, partDB)
+}
- partDB, err := db.MakeAccessor(t.Name()+"_part", false, true)
- a.NoError(err)
- a.NotNil(partDB)
+func setupParticipationKey(t *testing.T, a *require.Assertions) (PersistedParticipation, db.Accessor, db.Accessor, error) {
+ root, rootDB, partDB := createTestDBs(a, t.Name())
part, err := FillDBWithParticipationKeys(partDB, root.Address(), 0, 0, config.Consensus[protocol.ConsensusCurrentVersion].DefaultKeyDilution)
a.NoError(err)
@@ -55,9 +59,30 @@ func TestParticipation_NewDB(t *testing.T) {
versions, err := getSchemaVersions(partDB)
a.NoError(err)
a.Equal(versions[PartTableSchemaName], PartTableSchemaVersion)
+ return part, rootDB, partDB, err
+}
+func setupkeyWithNoDBS(t *testing.T, a *require.Assertions) PersistedParticipation {
+ part, rootDB, partDB, err := setupParticipationKey(t, a)
+ a.NoError(err)
+ a.NotNil(part)
+
+ closeDBS(rootDB, partDB)
+ return part
+}
+
+func createTestDBs(a *require.Assertions, name string) (Root, db.Accessor, db.Accessor) {
+ rootDB, err := db.MakeAccessor(name, false, true)
+ a.NoError(err)
+ a.NotNil(rootDB)
+ root, err := GenerateRoot(rootDB)
+ a.NoError(err)
+ a.NotNil(root)
- partDB.Close()
- rootDB.Close()
+ partDB, err := db.MakeAccessor(name+"_part", false, true)
+ a.NoError(err)
+ a.NotNil(partDB)
+
+ return root, rootDB, partDB
}
func getSchemaVersions(db db.Accessor) (versions map[string]int, err error) {
@@ -149,3 +174,278 @@ func BenchmarkOldKeysDeletion(b *testing.B) {
}
part.Close()
}
+
+func TestRetrieveFromDB(t *testing.T) {
+ a := require.New(t)
+ part, rootDB, partDB, err := setupParticipationKey(t, a)
+ a.NoError(err)
+ defer closeDBS(rootDB, partDB)
+
+ retrievedPart, err := RestoreParticipation(partDB)
+ a.NoError(err)
+ a.NotNil(retrievedPart)
+
+ // comparing the outputs:
+ a.Equal(intoComparable(part), intoComparable(retrievedPart))
+
+}
+
+func TestRetrieveFromDBAtVersion1(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+ ppart := setupkeyWithNoDBS(t, a)
+ _, rootDB, partDB := createTestDBs(a, t.Name())
+ defer closeDBS(rootDB, partDB)
+
+ part := ppart.Participation
+ a.NoError(setupTestDBAtVer1(partDB, part))
+
+ retrivedPart, err := RestoreParticipation(partDB)
+ a.NoError(err)
+ assertionForRestoringFromDBAtLowVersion(a, retrivedPart)
+}
+
+func TestRetriveFromDBAtVersion2(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+
+ ppart := setupkeyWithNoDBS(t, a)
+ _, rootDB, partDB := createTestDBs(a, t.Name())
+ defer closeDBS(rootDB, partDB)
+
+ part := ppart.Participation
+ a.NoError(setupTestDBAtVer2(partDB, part))
+
+ retrivedPart, err := RestoreParticipation(partDB)
+ a.NoError(err)
+ assertionForRestoringFromDBAtLowVersion(a, retrivedPart)
+}
+
+func TestKeyRegCreation(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+
+ ppart := setupkeyWithNoDBS(t, a)
+
+ cur := config.Consensus[protocol.ConsensusCurrentVersion]
+ txn := ppart.Participation.GenerateRegistrationTransaction(basics.MicroAlgos{Raw: 1000}, 0, 100, [32]byte{}, cur)
+ a.Equal(merklekeystore.Verifier{}, txn.BlockProofPK)
+
+ future := config.Consensus[protocol.ConsensusFuture]
+ txn = ppart.Participation.GenerateRegistrationTransaction(basics.MicroAlgos{Raw: 1000}, 0, 100, [32]byte{}, future)
+ a.NotEqual(merklekeystore.Verifier{}, txn.BlockProofPK)
+}
+
+func closeDBS(dbAccessor ...db.Accessor) {
+ for _, accessor := range dbAccessor {
+ accessor.Close()
+ }
+}
+
+func assertionForRestoringFromDBAtLowVersion(a *require.Assertions, retrivedPart PersistedParticipation) {
+ a.NotNil(retrivedPart)
+ a.Nil(retrivedPart.BlockProof)
+}
+
+func TestMigrateFromVersion1(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+ part := setupkeyWithNoDBS(t, a).Participation
+
+ _, rootDB, partDB := createTestDBs(a, t.Name())
+ defer closeDBS(rootDB, partDB)
+
+ a.NoError(setupTestDBAtVer1(partDB, part))
+ a.NoError(Migrate(partDB))
+
+ a.NoError(testDBContainsAllColumns(partDB))
+}
+
+func TestMigrationFromVersion2(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ a := require.New(t)
+ part := setupkeyWithNoDBS(t, a).Participation
+
+ _, rootDB, partDB := createTestDBs(a, t.Name())
+ defer closeDBS(rootDB, partDB)
+
+ a.NoError(setupTestDBAtVer2(partDB, part))
+ a.NoError(Migrate(partDB))
+
+ a.NoError(testDBContainsAllColumns(partDB))
+}
+
+func testDBContainsAllColumns(partDB db.Accessor) error {
+ return partDB.Atomic(func(ctx context.Context, tx *sql.Tx) error {
+ _, err := tx.Exec(fmt.Sprintf("select %v From ParticipationAccount;",
+ strings.Join(partableColumnNames[:], ",")))
+ return err
+ })
+}
+
+func setupTestDBAtVer2(partDB db.Accessor, part Participation) error {
+ rawVRF := protocol.Encode(part.VRF)
+ voting := part.Voting.Snapshot()
+ rawVoting := protocol.Encode(&voting)
+
+ return partDB.Atomic(func(ctx context.Context, tx *sql.Tx) error {
+ //set up an actual DB..
+ _, err := tx.Exec(`CREATE TABLE ParticipationAccount (
+ parent BLOB,
+
+ vrf BLOB,
+ voting BLOB,
+
+ firstValid INTEGER,
+ lastValid INTEGER,
+
+ keyDilution INTEGER NOT NULL DEFAULT 0
+ );`)
+ if err != nil {
+ return nil
+ }
+
+ if err := setupSchemaForTest(tx, 2); err != nil {
+ return err
+ }
+ _, err = tx.Exec("INSERT INTO ParticipationAccount (parent, vrf, voting, firstValid, lastValid, keyDilution) VALUES (?, ?, ?, ?, ?, ?)",
+ part.Parent[:], rawVRF, rawVoting, part.FirstValid, part.LastValid, part.KeyDilution)
+ if err != nil {
+ return err
+ }
+ return nil
+ })
+}
+
+func setupSchemaForTest(tx *sql.Tx, version int) error {
+ _, err := tx.Exec(`CREATE TABLE schema (tablename TEXT PRIMARY KEY, version INTEGER);`)
+ if err != nil {
+ return nil
+ }
+
+ _, err = tx.Exec("INSERT INTO schema (tablename, version) VALUES (?, ?)", PartTableSchemaName, version)
+ if err != nil {
+ return nil
+ }
+ return err
+}
+
+func setupTestDBAtVer1(partDB db.Accessor, part Participation) error {
+ rawVRF := protocol.Encode(part.VRF)
+ voting := part.Voting.Snapshot()
+ rawVoting := protocol.Encode(&voting)
+
+ return partDB.Atomic(func(ctx context.Context, tx *sql.Tx) error {
+ //set up an actual DB..
+ _, err := tx.Exec(`CREATE TABLE ParticipationAccount (
+ parent BLOB,
+
+ vrf BLOB,
+ voting BLOB,
+
+ firstValid INTEGER,
+ lastValid INTEGER
+ );`)
+ if err != nil {
+ return err
+ }
+
+ if err := setupSchemaForTest(tx, 1); err != nil {
+ return err
+ }
+ _, err = tx.Exec("INSERT INTO ParticipationAccount (parent, vrf, voting, firstValid, lastValid) VALUES (?, ?, ?, ?, ?)",
+ part.Parent[:], rawVRF, rawVoting, part.FirstValid, part.LastValid)
+ if err != nil {
+ return err
+ }
+ return nil
+ })
+}
+
+type comparablePartition struct {
+ Parent basics.Address
+
+ VRF crypto.VRFSecrets
+ Voting []byte
+ blockProof []byte
+
+ FirstValid basics.Round
+ LastValid basics.Round
+
+ KeyDilution uint64
+}
+
+func intoComparable(part PersistedParticipation) comparablePartition {
+ return comparablePartition{
+ Parent: part.Parent,
+ VRF: *part.VRF,
+ Voting: part.Voting.MarshalMsg(nil),
+ blockProof: protocol.Encode(part.BlockProof),
+ FirstValid: part.FirstValid,
+ LastValid: part.LastValid,
+ KeyDilution: part.KeyDilution,
+ }
+}
+
+func BenchmarkFillDB(b *testing.B) {
+ a := require.New(b)
+ root, _, partDB := createTestDBs(a, b.Name()+strconv.Itoa(b.N))
+
+ tmp := config.Consensus[protocol.ConsensusCurrentVersion]
+ cpy := config.Consensus[protocol.ConsensusCurrentVersion]
+ cpy.CompactCertRounds = 128
+ config.Consensus[protocol.ConsensusCurrentVersion] = cpy
+ defer func() { config.Consensus[protocol.ConsensusCurrentVersion] = tmp }()
+
+ for i := 0; i < b.N; i++ {
+ _, err := FillDBWithParticipationKeys(partDB, root.Address(), 0, 3000000, config.Consensus[protocol.ConsensusCurrentVersion].DefaultKeyDilution)
+ b.StopTimer()
+ a.NoError(err)
+
+ a.NoError(dropTables(partDB))
+ b.StartTimer()
+ }
+}
+
+func dropTables(partDB db.Accessor) error {
+ return partDB.Atomic(func(ctx context.Context, tx *sql.Tx) error {
+ _, err := tx.Exec("DROP TABLE ParticipationAccount;")
+ if err != nil {
+ return err
+ }
+ _, err = tx.Exec("DROP TABLE schema;")
+ return err
+ })
+}
+
+func BenchmarkParticipationKeyRestoration(b *testing.B) {
+ a := require.New(b)
+
+ var rootAddr basics.Address
+ crypto.RandBytes(rootAddr[:])
+
+ dbname := b.Name() + "_part"
+ defer os.Remove(dbname)
+
+ partDB, err := db.MakeErasableAccessor(dbname)
+ a.NoError(err)
+
+ part, err := FillDBWithParticipationKeys(partDB, rootAddr, 0, 3000000, config.Consensus[protocol.ConsensusCurrentVersion].DefaultKeyDilution)
+ a.NoError(err)
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ out, err := RestoreParticipation(partDB)
+ a.NoError(err)
+
+ b.StopTimer()
+ a.Equal(intoComparable(part), intoComparable(out))
+ b.StartTimer()
+ }
+ part.Close()
+}
diff --git a/data/accountManager.go b/data/accountManager.go
index 79a57287b..40f865883 100644
--- a/data/accountManager.go
+++ b/data/accountManager.go
@@ -151,6 +151,7 @@ func (manager *AccountManager) DeleteOldKeys(latestHdr bookkeeping.BlockHeader,
// We need a key for round r+1 for agreement.
nextRound := latestHdr.Round + 1
+ // TODO: we might not need this!
if latestHdr.CompactCert[protocol.CompactCertBasic].CompactCertNextRound > 0 {
// We need a key for the next compact cert round.
// This would be CompactCertNextRound+1 (+1 because compact
diff --git a/data/basics/ccertpart.go b/data/basics/ccertpart.go
index 097cb6c27..0e61c5ff5 100644
--- a/data/basics/ccertpart.go
+++ b/data/basics/ccertpart.go
@@ -17,7 +17,7 @@
package basics
import (
- "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/protocol"
)
@@ -33,15 +33,14 @@ import (
type Participant struct {
_struct struct{} `codec:",omitempty,omitemptyarray"`
- // PK is AccountData.VoteID.
- PK crypto.OneTimeSignatureVerifier `codec:"p"`
+ // PK is the identifier used to verify the signature for a specific participant
+ PK merklekeystore.Verifier `codec:"p"`
// Weight is AccountData.MicroAlgos.
Weight uint64 `codec:"w"`
- // KeyDilution is AccountData.KeyDilution() with the protocol for sigRound
- // as expected by the Builder.
- KeyDilution uint64 `codec:"d"`
+ // FirstValid reprents the first round where the commitment is valid
+ FirstValid uint64 `codec:"fv"`
}
// ToBeHashed implements the crypto.Hashable interface.
diff --git a/data/basics/msgp_gen.go b/data/basics/msgp_gen.go
index 57cef5e5d..a6f29e319 100644
--- a/data/basics/msgp_gen.go
+++ b/data/basics/msgp_gen.go
@@ -200,8 +200,8 @@ import (
func (z *AccountData) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0009Len := uint32(16)
- var zb0009Mask uint32 /* 17 bits */
+ zb0009Len := uint32(17)
+ var zb0009Mask uint32 /* 18 bits */
if (*z).MicroAlgos.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x2
@@ -222,50 +222,54 @@ func (z *AccountData) MarshalMsg(b []byte) (o []byte) {
zb0009Len--
zb0009Mask |= 0x20
}
- if (*z).RewardsBase == 0 {
+ if (*z).BlockProofID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x40
}
- if (*z).RewardedMicroAlgos.MsgIsZero() {
+ if (*z).RewardsBase == 0 {
zb0009Len--
zb0009Mask |= 0x80
}
- if (*z).Status == 0 {
+ if (*z).RewardedMicroAlgos.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x100
}
- if (*z).SelectionID.MsgIsZero() {
+ if (*z).Status == 0 {
zb0009Len--
zb0009Mask |= 0x200
}
- if (*z).AuthAddr.MsgIsZero() {
+ if (*z).SelectionID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x400
}
- if (*z).TotalExtraAppPages == 0 {
+ if (*z).AuthAddr.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x800
}
- if ((*z).TotalAppSchema.NumUint == 0) && ((*z).TotalAppSchema.NumByteSlice == 0) {
+ if (*z).TotalExtraAppPages == 0 {
zb0009Len--
zb0009Mask |= 0x1000
}
- if (*z).VoteID.MsgIsZero() {
+ if ((*z).TotalAppSchema.NumUint == 0) && ((*z).TotalAppSchema.NumByteSlice == 0) {
zb0009Len--
zb0009Mask |= 0x2000
}
- if (*z).VoteFirstValid == 0 {
+ if (*z).VoteID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x4000
}
- if (*z).VoteKeyDilution == 0 {
+ if (*z).VoteFirstValid == 0 {
zb0009Len--
zb0009Mask |= 0x8000
}
- if (*z).VoteLastValid == 0 {
+ if (*z).VoteKeyDilution == 0 {
zb0009Len--
zb0009Mask |= 0x10000
}
+ if (*z).VoteLastValid == 0 {
+ zb0009Len--
+ zb0009Mask |= 0x20000
+ }
// variable map header, size zb0009Len
o = msgp.AppendMapHeader(o, zb0009Len)
if zb0009Len != 0 {
@@ -379,36 +383,41 @@ func (z *AccountData) MarshalMsg(b []byte) (o []byte) {
}
}
if (zb0009Mask & 0x40) == 0 { // if not empty
+ // string "blkprf"
+ o = append(o, 0xa6, 0x62, 0x6c, 0x6b, 0x70, 0x72, 0x66)
+ o = (*z).BlockProofID.MarshalMsg(o)
+ }
+ if (zb0009Mask & 0x80) == 0 { // if not empty
// string "ebase"
o = append(o, 0xa5, 0x65, 0x62, 0x61, 0x73, 0x65)
o = msgp.AppendUint64(o, (*z).RewardsBase)
}
- if (zb0009Mask & 0x80) == 0 { // if not empty
+ if (zb0009Mask & 0x100) == 0 { // if not empty
// string "ern"
o = append(o, 0xa3, 0x65, 0x72, 0x6e)
o = (*z).RewardedMicroAlgos.MarshalMsg(o)
}
- if (zb0009Mask & 0x100) == 0 { // if not empty
+ if (zb0009Mask & 0x200) == 0 { // if not empty
// string "onl"
o = append(o, 0xa3, 0x6f, 0x6e, 0x6c)
o = msgp.AppendByte(o, byte((*z).Status))
}
- if (zb0009Mask & 0x200) == 0 { // if not empty
+ if (zb0009Mask & 0x400) == 0 { // if not empty
// string "sel"
o = append(o, 0xa3, 0x73, 0x65, 0x6c)
o = (*z).SelectionID.MarshalMsg(o)
}
- if (zb0009Mask & 0x400) == 0 { // if not empty
+ if (zb0009Mask & 0x800) == 0 { // if not empty
// string "spend"
o = append(o, 0xa5, 0x73, 0x70, 0x65, 0x6e, 0x64)
o = (*z).AuthAddr.MarshalMsg(o)
}
- if (zb0009Mask & 0x800) == 0 { // if not empty
+ if (zb0009Mask & 0x1000) == 0 { // if not empty
// string "teap"
o = append(o, 0xa4, 0x74, 0x65, 0x61, 0x70)
o = msgp.AppendUint32(o, (*z).TotalExtraAppPages)
}
- if (zb0009Mask & 0x1000) == 0 { // if not empty
+ if (zb0009Mask & 0x2000) == 0 { // if not empty
// string "tsch"
o = append(o, 0xa4, 0x74, 0x73, 0x63, 0x68)
// omitempty: check for empty values
@@ -435,22 +444,22 @@ func (z *AccountData) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).TotalAppSchema.NumUint)
}
}
- if (zb0009Mask & 0x2000) == 0 { // if not empty
+ if (zb0009Mask & 0x4000) == 0 { // if not empty
// string "vote"
o = append(o, 0xa4, 0x76, 0x6f, 0x74, 0x65)
o = (*z).VoteID.MarshalMsg(o)
}
- if (zb0009Mask & 0x4000) == 0 { // if not empty
+ if (zb0009Mask & 0x8000) == 0 { // if not empty
// string "voteFst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x46, 0x73, 0x74)
o = msgp.AppendUint64(o, uint64((*z).VoteFirstValid))
}
- if (zb0009Mask & 0x8000) == 0 { // if not empty
+ if (zb0009Mask & 0x10000) == 0 { // if not empty
// string "voteKD"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x4b, 0x44)
o = msgp.AppendUint64(o, (*z).VoteKeyDilution)
}
- if (zb0009Mask & 0x10000) == 0 { // if not empty
+ if (zb0009Mask & 0x20000) == 0 { // if not empty
// string "voteLst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x4c, 0x73, 0x74)
o = msgp.AppendUint64(o, uint64((*z).VoteLastValid))
@@ -531,6 +540,14 @@ func (z *AccountData) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
if zb0009 > 0 {
zb0009--
+ bts, err = (*z).BlockProofID.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BlockProofID")
+ return
+ }
+ }
+ if zb0009 > 0 {
+ zb0009--
{
var zb0012 uint64
zb0012, bts, err = msgp.ReadUint64Bytes(bts)
@@ -920,6 +937,12 @@ func (z *AccountData) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "SelectionID")
return
}
+ case "blkprf":
+ bts, err = (*z).BlockProofID.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BlockProofID")
+ return
+ }
case "voteFst":
{
var zb0027 uint64
@@ -1248,7 +1271,7 @@ func (_ *AccountData) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *AccountData) Msgsize() (s int) {
- s = 3 + 4 + msgp.ByteSize + 5 + (*z).MicroAlgos.Msgsize() + 6 + msgp.Uint64Size + 4 + (*z).RewardedMicroAlgos.Msgsize() + 5 + (*z).VoteID.Msgsize() + 4 + (*z).SelectionID.Msgsize() + 8 + msgp.Uint64Size + 8 + msgp.Uint64Size + 7 + msgp.Uint64Size + 5 + msgp.MapHeaderSize
+ s = 3 + 4 + msgp.ByteSize + 5 + (*z).MicroAlgos.Msgsize() + 6 + msgp.Uint64Size + 4 + (*z).RewardedMicroAlgos.Msgsize() + 5 + (*z).VoteID.Msgsize() + 4 + (*z).SelectionID.Msgsize() + 7 + (*z).BlockProofID.Msgsize() + 8 + msgp.Uint64Size + 8 + msgp.Uint64Size + 7 + msgp.Uint64Size + 5 + msgp.MapHeaderSize
if (*z).AssetParams != nil {
for zb0001, zb0002 := range (*z).AssetParams {
_ = zb0001
@@ -1286,7 +1309,7 @@ func (z *AccountData) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *AccountData) MsgIsZero() bool {
- return ((*z).Status == 0) && ((*z).MicroAlgos.MsgIsZero()) && ((*z).RewardsBase == 0) && ((*z).RewardedMicroAlgos.MsgIsZero()) && ((*z).VoteID.MsgIsZero()) && ((*z).SelectionID.MsgIsZero()) && ((*z).VoteFirstValid == 0) && ((*z).VoteLastValid == 0) && ((*z).VoteKeyDilution == 0) && (len((*z).AssetParams) == 0) && (len((*z).Assets) == 0) && ((*z).AuthAddr.MsgIsZero()) && (len((*z).AppLocalStates) == 0) && (len((*z).AppParams) == 0) && (((*z).TotalAppSchema.NumUint == 0) && ((*z).TotalAppSchema.NumByteSlice == 0)) && ((*z).TotalExtraAppPages == 0)
+ return ((*z).Status == 0) && ((*z).MicroAlgos.MsgIsZero()) && ((*z).RewardsBase == 0) && ((*z).RewardedMicroAlgos.MsgIsZero()) && ((*z).VoteID.MsgIsZero()) && ((*z).SelectionID.MsgIsZero()) && ((*z).BlockProofID.MsgIsZero()) && ((*z).VoteFirstValid == 0) && ((*z).VoteLastValid == 0) && ((*z).VoteKeyDilution == 0) && (len((*z).AssetParams) == 0) && (len((*z).Assets) == 0) && ((*z).AuthAddr.MsgIsZero()) && (len((*z).AppLocalStates) == 0) && (len((*z).AppParams) == 0) && (((*z).TotalAppSchema.NumUint == 0) && ((*z).TotalAppSchema.NumByteSlice == 0)) && ((*z).TotalExtraAppPages == 0)
}
// MarshalMsg implements msgp.Marshaler
@@ -2875,8 +2898,8 @@ func (z *AssetParams) MsgIsZero() bool {
func (z *BalanceRecord) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0009Len := uint32(17)
- var zb0009Mask uint32 /* 19 bits */
+ zb0009Len := uint32(18)
+ var zb0009Mask uint32 /* 20 bits */
if (*z).Addr.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x4
@@ -2901,50 +2924,54 @@ func (z *BalanceRecord) MarshalMsg(b []byte) (o []byte) {
zb0009Len--
zb0009Mask |= 0x80
}
- if (*z).AccountData.RewardsBase == 0 {
+ if (*z).AccountData.BlockProofID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x100
}
- if (*z).AccountData.RewardedMicroAlgos.MsgIsZero() {
+ if (*z).AccountData.RewardsBase == 0 {
zb0009Len--
zb0009Mask |= 0x200
}
- if (*z).AccountData.Status == 0 {
+ if (*z).AccountData.RewardedMicroAlgos.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x400
}
- if (*z).AccountData.SelectionID.MsgIsZero() {
+ if (*z).AccountData.Status == 0 {
zb0009Len--
zb0009Mask |= 0x800
}
- if (*z).AccountData.AuthAddr.MsgIsZero() {
+ if (*z).AccountData.SelectionID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x1000
}
- if (*z).AccountData.TotalExtraAppPages == 0 {
+ if (*z).AccountData.AuthAddr.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x2000
}
- if ((*z).AccountData.TotalAppSchema.NumUint == 0) && ((*z).AccountData.TotalAppSchema.NumByteSlice == 0) {
+ if (*z).AccountData.TotalExtraAppPages == 0 {
zb0009Len--
zb0009Mask |= 0x4000
}
- if (*z).AccountData.VoteID.MsgIsZero() {
+ if ((*z).AccountData.TotalAppSchema.NumUint == 0) && ((*z).AccountData.TotalAppSchema.NumByteSlice == 0) {
zb0009Len--
zb0009Mask |= 0x8000
}
- if (*z).AccountData.VoteFirstValid == 0 {
+ if (*z).AccountData.VoteID.MsgIsZero() {
zb0009Len--
zb0009Mask |= 0x10000
}
- if (*z).AccountData.VoteKeyDilution == 0 {
+ if (*z).AccountData.VoteFirstValid == 0 {
zb0009Len--
zb0009Mask |= 0x20000
}
- if (*z).AccountData.VoteLastValid == 0 {
+ if (*z).AccountData.VoteKeyDilution == 0 {
zb0009Len--
zb0009Mask |= 0x40000
}
+ if (*z).AccountData.VoteLastValid == 0 {
+ zb0009Len--
+ zb0009Mask |= 0x80000
+ }
// variable map header, size zb0009Len
o = msgp.AppendMapHeader(o, zb0009Len)
if zb0009Len != 0 {
@@ -3063,36 +3090,41 @@ func (z *BalanceRecord) MarshalMsg(b []byte) (o []byte) {
}
}
if (zb0009Mask & 0x100) == 0 { // if not empty
+ // string "blkprf"
+ o = append(o, 0xa6, 0x62, 0x6c, 0x6b, 0x70, 0x72, 0x66)
+ o = (*z).AccountData.BlockProofID.MarshalMsg(o)
+ }
+ if (zb0009Mask & 0x200) == 0 { // if not empty
// string "ebase"
o = append(o, 0xa5, 0x65, 0x62, 0x61, 0x73, 0x65)
o = msgp.AppendUint64(o, (*z).AccountData.RewardsBase)
}
- if (zb0009Mask & 0x200) == 0 { // if not empty
+ if (zb0009Mask & 0x400) == 0 { // if not empty
// string "ern"
o = append(o, 0xa3, 0x65, 0x72, 0x6e)
o = (*z).AccountData.RewardedMicroAlgos.MarshalMsg(o)
}
- if (zb0009Mask & 0x400) == 0 { // if not empty
+ if (zb0009Mask & 0x800) == 0 { // if not empty
// string "onl"
o = append(o, 0xa3, 0x6f, 0x6e, 0x6c)
o = msgp.AppendByte(o, byte((*z).AccountData.Status))
}
- if (zb0009Mask & 0x800) == 0 { // if not empty
+ if (zb0009Mask & 0x1000) == 0 { // if not empty
// string "sel"
o = append(o, 0xa3, 0x73, 0x65, 0x6c)
o = (*z).AccountData.SelectionID.MarshalMsg(o)
}
- if (zb0009Mask & 0x1000) == 0 { // if not empty
+ if (zb0009Mask & 0x2000) == 0 { // if not empty
// string "spend"
o = append(o, 0xa5, 0x73, 0x70, 0x65, 0x6e, 0x64)
o = (*z).AccountData.AuthAddr.MarshalMsg(o)
}
- if (zb0009Mask & 0x2000) == 0 { // if not empty
+ if (zb0009Mask & 0x4000) == 0 { // if not empty
// string "teap"
o = append(o, 0xa4, 0x74, 0x65, 0x61, 0x70)
o = msgp.AppendUint32(o, (*z).AccountData.TotalExtraAppPages)
}
- if (zb0009Mask & 0x4000) == 0 { // if not empty
+ if (zb0009Mask & 0x8000) == 0 { // if not empty
// string "tsch"
o = append(o, 0xa4, 0x74, 0x73, 0x63, 0x68)
// omitempty: check for empty values
@@ -3119,22 +3151,22 @@ func (z *BalanceRecord) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).AccountData.TotalAppSchema.NumUint)
}
}
- if (zb0009Mask & 0x8000) == 0 { // if not empty
+ if (zb0009Mask & 0x10000) == 0 { // if not empty
// string "vote"
o = append(o, 0xa4, 0x76, 0x6f, 0x74, 0x65)
o = (*z).AccountData.VoteID.MarshalMsg(o)
}
- if (zb0009Mask & 0x10000) == 0 { // if not empty
+ if (zb0009Mask & 0x20000) == 0 { // if not empty
// string "voteFst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x46, 0x73, 0x74)
o = msgp.AppendUint64(o, uint64((*z).AccountData.VoteFirstValid))
}
- if (zb0009Mask & 0x20000) == 0 { // if not empty
+ if (zb0009Mask & 0x40000) == 0 { // if not empty
// string "voteKD"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x4b, 0x44)
o = msgp.AppendUint64(o, (*z).AccountData.VoteKeyDilution)
}
- if (zb0009Mask & 0x40000) == 0 { // if not empty
+ if (zb0009Mask & 0x80000) == 0 { // if not empty
// string "voteLst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x4c, 0x73, 0x74)
o = msgp.AppendUint64(o, uint64((*z).AccountData.VoteLastValid))
@@ -3223,6 +3255,14 @@ func (z *BalanceRecord) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
if zb0009 > 0 {
zb0009--
+ bts, err = (*z).AccountData.BlockProofID.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BlockProofID")
+ return
+ }
+ }
+ if zb0009 > 0 {
+ zb0009--
{
var zb0012 uint64
zb0012, bts, err = msgp.ReadUint64Bytes(bts)
@@ -3618,6 +3658,12 @@ func (z *BalanceRecord) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "SelectionID")
return
}
+ case "blkprf":
+ bts, err = (*z).AccountData.BlockProofID.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BlockProofID")
+ return
+ }
case "voteFst":
{
var zb0027 uint64
@@ -3946,7 +3992,7 @@ func (_ *BalanceRecord) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BalanceRecord) Msgsize() (s int) {
- s = 3 + 5 + (*z).Addr.Msgsize() + 4 + msgp.ByteSize + 5 + (*z).AccountData.MicroAlgos.Msgsize() + 6 + msgp.Uint64Size + 4 + (*z).AccountData.RewardedMicroAlgos.Msgsize() + 5 + (*z).AccountData.VoteID.Msgsize() + 4 + (*z).AccountData.SelectionID.Msgsize() + 8 + msgp.Uint64Size + 8 + msgp.Uint64Size + 7 + msgp.Uint64Size + 5 + msgp.MapHeaderSize
+ s = 3 + 5 + (*z).Addr.Msgsize() + 4 + msgp.ByteSize + 5 + (*z).AccountData.MicroAlgos.Msgsize() + 6 + msgp.Uint64Size + 4 + (*z).AccountData.RewardedMicroAlgos.Msgsize() + 5 + (*z).AccountData.VoteID.Msgsize() + 4 + (*z).AccountData.SelectionID.Msgsize() + 7 + (*z).AccountData.BlockProofID.Msgsize() + 8 + msgp.Uint64Size + 8 + msgp.Uint64Size + 7 + msgp.Uint64Size + 5 + msgp.MapHeaderSize
if (*z).AccountData.AssetParams != nil {
for zb0001, zb0002 := range (*z).AccountData.AssetParams {
_ = zb0001
@@ -3984,7 +4030,7 @@ func (z *BalanceRecord) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *BalanceRecord) MsgIsZero() bool {
- return ((*z).Addr.MsgIsZero()) && ((*z).AccountData.Status == 0) && ((*z).AccountData.MicroAlgos.MsgIsZero()) && ((*z).AccountData.RewardsBase == 0) && ((*z).AccountData.RewardedMicroAlgos.MsgIsZero()) && ((*z).AccountData.VoteID.MsgIsZero()) && ((*z).AccountData.SelectionID.MsgIsZero()) && ((*z).AccountData.VoteFirstValid == 0) && ((*z).AccountData.VoteLastValid == 0) && ((*z).AccountData.VoteKeyDilution == 0) && (len((*z).AccountData.AssetParams) == 0) && (len((*z).AccountData.Assets) == 0) && ((*z).AccountData.AuthAddr.MsgIsZero()) && (len((*z).AccountData.AppLocalStates) == 0) && (len((*z).AccountData.AppParams) == 0) && (((*z).AccountData.TotalAppSchema.NumUint == 0) && ((*z).AccountData.TotalAppSchema.NumByteSlice == 0)) && ((*z).AccountData.TotalExtraAppPages == 0)
+ return ((*z).Addr.MsgIsZero()) && ((*z).AccountData.Status == 0) && ((*z).AccountData.MicroAlgos.MsgIsZero()) && ((*z).AccountData.RewardsBase == 0) && ((*z).AccountData.RewardedMicroAlgos.MsgIsZero()) && ((*z).AccountData.VoteID.MsgIsZero()) && ((*z).AccountData.SelectionID.MsgIsZero()) && ((*z).AccountData.BlockProofID.MsgIsZero()) && ((*z).AccountData.VoteFirstValid == 0) && ((*z).AccountData.VoteLastValid == 0) && ((*z).AccountData.VoteKeyDilution == 0) && (len((*z).AccountData.AssetParams) == 0) && (len((*z).AccountData.Assets) == 0) && ((*z).AccountData.AuthAddr.MsgIsZero()) && (len((*z).AccountData.AppLocalStates) == 0) && (len((*z).AccountData.AppParams) == 0) && (((*z).AccountData.TotalAppSchema.NumUint == 0) && ((*z).AccountData.TotalAppSchema.NumByteSlice == 0)) && ((*z).AccountData.TotalExtraAppPages == 0)
}
// MarshalMsg implements msgp.Marshaler
@@ -4131,7 +4177,7 @@ func (z *Participant) MarshalMsg(b []byte) (o []byte) {
// omitempty: check for empty values
zb0001Len := uint32(3)
var zb0001Mask uint8 /* 4 bits */
- if (*z).KeyDilution == 0 {
+ if (*z).FirstValid == 0 {
zb0001Len--
zb0001Mask |= 0x2
}
@@ -4147,9 +4193,9 @@ func (z *Participant) MarshalMsg(b []byte) (o []byte) {
o = append(o, 0x80|uint8(zb0001Len))
if zb0001Len != 0 {
if (zb0001Mask & 0x2) == 0 { // if not empty
- // string "d"
- o = append(o, 0xa1, 0x64)
- o = msgp.AppendUint64(o, (*z).KeyDilution)
+ // string "fv"
+ o = append(o, 0xa2, 0x66, 0x76)
+ o = msgp.AppendUint64(o, (*z).FirstValid)
}
if (zb0001Mask & 0x4) == 0 { // if not empty
// string "p"
@@ -4201,9 +4247,9 @@ func (z *Participant) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
if zb0001 > 0 {
zb0001--
- (*z).KeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
+ (*z).FirstValid, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "KeyDilution")
+ err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
}
@@ -4242,10 +4288,10 @@ func (z *Participant) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "Weight")
return
}
- case "d":
- (*z).KeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
+ case "fv":
+ (*z).FirstValid, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "KeyDilution")
+ err = msgp.WrapError(err, "FirstValid")
return
}
default:
@@ -4268,13 +4314,13 @@ func (_ *Participant) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Participant) Msgsize() (s int) {
- s = 1 + 2 + (*z).PK.Msgsize() + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size
+ s = 1 + 2 + (*z).PK.Msgsize() + 2 + msgp.Uint64Size + 3 + msgp.Uint64Size
return
}
// MsgIsZero returns whether this is a zero value
func (z *Participant) MsgIsZero() bool {
- return ((*z).PK.MsgIsZero()) && ((*z).Weight == 0) && ((*z).KeyDilution == 0)
+ return ((*z).PK.MsgIsZero()) && ((*z).Weight == 0) && ((*z).FirstValid == 0)
}
// MarshalMsg implements msgp.Marshaler
diff --git a/data/basics/userBalance.go b/data/basics/userBalance.go
index b427a2f99..6427831b8 100644
--- a/data/basics/userBalance.go
+++ b/data/basics/userBalance.go
@@ -19,6 +19,7 @@ package basics
import (
"encoding/binary"
"fmt"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"reflect"
"github.com/algorand/go-algorand/config"
@@ -160,8 +161,9 @@ type AccountData struct {
// the past week".
RewardedMicroAlgos MicroAlgos `codec:"ern"`
- VoteID crypto.OneTimeSignatureVerifier `codec:"vote"`
- SelectionID crypto.VRFVerifier `codec:"sel"`
+ VoteID crypto.OneTimeSignatureVerifier `codec:"vote"`
+ SelectionID crypto.VRFVerifier `codec:"sel"`
+ BlockProofID merklekeystore.Verifier `codec:"blkprf"`
VoteFirstValid Round `codec:"voteFst"`
VoteLastValid Round `codec:"voteLst"`
diff --git a/data/bookkeeping/block.go b/data/bookkeeping/block.go
index bb9ae321b..5ae0f4b19 100644
--- a/data/bookkeeping/block.go
+++ b/data/bookkeeping/block.go
@@ -214,7 +214,7 @@ type (
// are a multiple of ConsensusParams.CompactCertRounds. For blocks
// that are not a multiple of ConsensusParams.CompactCertRounds,
// this value is zero.
- CompactCertVoters crypto.Digest `codec:"v"`
+ CompactCertVoters crypto.GenericDigest `codec:"v"`
// CompactCertVotersTotal is the total number of microalgos held by
// the accounts in CompactCertVoters (or zero, if the merkle root is
@@ -519,7 +519,7 @@ func (block Block) paysetCommit(t config.PaysetCommitType) (crypto.Digest, error
if err != nil {
return crypto.Digest{}, err
}
- return tree.Root(), nil
+ return tree.Root().To32Byte(), nil
default:
return crypto.Digest{}, fmt.Errorf("unsupported payset commit type %d", t)
}
diff --git a/data/bookkeeping/txn_merkle.go b/data/bookkeeping/txn_merkle.go
index 043a09cc8..eb6dfba5d 100644
--- a/data/bookkeeping/txn_merkle.go
+++ b/data/bookkeeping/txn_merkle.go
@@ -31,7 +31,7 @@ import (
// header), or to generate proofs of membership for transactions that are
// in this block.
func (block Block) TxnMerkleTree() (*merklearray.Tree, error) {
- return merklearray.Build(&txnMerkleArray{block: block})
+ return merklearray.Build(&txnMerkleArray{block: block}, crypto.HashFactory{HashType: crypto.Sha512_256})
}
// txnMerkleArray is a representation of the transactions in this block,
@@ -46,9 +46,9 @@ func (tma *txnMerkleArray) Length() uint64 {
}
// Get implements the merklearray.Array interface.
-func (tma *txnMerkleArray) GetHash(pos uint64) (crypto.Digest, error) {
+func (tma *txnMerkleArray) Marshal(pos uint64) ([]byte, error) {
if pos >= uint64(len(tma.block.Payset)) {
- return crypto.Digest{}, fmt.Errorf("txnMerkleArray.Get(%d): out of bounds, payset size %d", pos, len(tma.block.Payset))
+ return nil, fmt.Errorf("txnMerkleArray.Get(%d): out of bounds, payset size %d", pos, len(tma.block.Payset))
}
var elem txnMerkleElem
@@ -56,11 +56,11 @@ func (tma *txnMerkleArray) GetHash(pos uint64) (crypto.Digest, error) {
stxn, _, err := tma.block.DecodeSignedTxn(elem.stib)
if err != nil {
- return crypto.Digest{}, err
+ return nil, err
}
elem.txn = stxn.Txn
- return elem.Hash(), nil
+ return elem.HashRepresentation(), nil
}
// txnMerkleElem represents a leaf in the Merkle tree of all transactions
@@ -70,6 +70,12 @@ type txnMerkleElem struct {
stib transactions.SignedTxnInBlock
}
+func txnMerkleToRaw(txid []byte, stib []byte) []byte {
+ buf := make([]byte, 0, 2*crypto.DigestSize)
+ buf = append(buf, txid...)
+ return append(buf, stib...)
+}
+
// ToBeHashed implements the crypto.Hashable interface.
func (tme *txnMerkleElem) ToBeHashed() (protocol.HashID, []byte) {
// The leaf contains two hashes: the transaction ID (hash of the
@@ -77,22 +83,21 @@ func (tme *txnMerkleElem) ToBeHashed() (protocol.HashID, []byte) {
txid := tme.txn.ID()
stib := crypto.HashObj(&tme.stib)
- var buf [2 * crypto.DigestSize]byte
- copy(buf[:crypto.DigestSize], txid[:])
- copy(buf[crypto.DigestSize:], stib[:])
-
- return protocol.TxnMerkleLeaf, buf[:]
+ return protocol.TxnMerkleLeaf, txnMerkleToRaw(txid[:], stib[:])
}
// Hash implements an optimized version of crypto.HashObj(tme).
func (tme *txnMerkleElem) Hash() crypto.Digest {
+ return crypto.Hash(tme.HashRepresentation())
+}
+
+func (tme *txnMerkleElem) HashRepresentation() []byte {
txid := tme.txn.ID()
stib := tme.stib.Hash()
var buf [len(protocol.TxnMerkleLeaf) + 2*crypto.DigestSize]byte
s := buf[:0]
s = append(s, protocol.TxnMerkleLeaf...)
- s = append(s, txid[:]...)
- s = append(s, stib[:]...)
- return crypto.Hash(s)
+ s = append(s, txnMerkleToRaw(txid[:], stib[:])...)
+ return s
}
diff --git a/data/bookkeeping/txn_merkle_test.go b/data/bookkeeping/txn_merkle_test.go
index 5f7d6b2db..f250350d5 100644
--- a/data/bookkeeping/txn_merkle_test.go
+++ b/data/bookkeeping/txn_merkle_test.go
@@ -77,12 +77,12 @@ func TestTxnMerkle(t *testing.T) {
require.NoError(t, err)
root := tree.Root()
+ require.NoError(t, err)
for i := uint64(0); i < ntxn; i++ {
proof, err := tree.Prove([]uint64{i})
require.NoError(t, err)
-
- elemVerif := make(map[uint64]crypto.Digest)
- elemVerif[i] = elems[i].Hash()
+ elemVerif := make(map[uint64]crypto.Hashable)
+ elemVerif[i] = &elems[i]
err = merklearray.Verify(root, elemVerif, proof)
require.NoError(t, err)
}
diff --git a/data/pools/transactionPool.go b/data/pools/transactionPool.go
index 2b145cc2d..a8afd583e 100644
--- a/data/pools/transactionPool.go
+++ b/data/pools/transactionPool.go
@@ -791,6 +791,7 @@ func (pool *TransactionPool) recomputeBlockEvaluator(committedTxIds map[transact
asmStats.EarlyCommittedCount++
continue
}
+
err := pool.add(txgroup, &asmStats)
if err != nil {
for _, tx := range txgroup.Transactions {
diff --git a/data/transactions/compactcert.go b/data/transactions/compactcert.go
index 2b1be0cd8..f4a7f6759 100644
--- a/data/transactions/compactcert.go
+++ b/data/transactions/compactcert.go
@@ -38,10 +38,10 @@ func (cc CompactCertTxnFields) Empty() bool {
if cc.CertRound != 0 {
return false
}
- if !cc.Cert.SigCommit.IsZero() || cc.Cert.SignedWeight != 0 {
+ if !cc.Cert.SigCommit.IsEmpty() || cc.Cert.SignedWeight != 0 {
return false
}
- if len(cc.Cert.SigProofs) != 0 || len(cc.Cert.PartProofs) != 0 {
+ if len(cc.Cert.SigProofs.Path) != 0 || len(cc.Cert.PartProofs.Path) != 0 {
return false
}
if len(cc.Cert.Reveals) != 0 {
diff --git a/data/transactions/keyreg.go b/data/transactions/keyreg.go
index cb354802b..28b262c6a 100644
--- a/data/transactions/keyreg.go
+++ b/data/transactions/keyreg.go
@@ -18,6 +18,7 @@ package transactions
import (
"github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
)
@@ -27,6 +28,7 @@ type KeyregTxnFields struct {
VotePK crypto.OneTimeSignatureVerifier `codec:"votekey"`
SelectionPK crypto.VRFVerifier `codec:"selkey"`
+ BlockProofPK merklekeystore.Verifier `codec:"bprfkey"`
VoteFirst basics.Round `codec:"votefst"`
VoteLast basics.Round `codec:"votelst"`
VoteKeyDilution uint64 `codec:"votekd"`
diff --git a/data/transactions/msgp_gen.go b/data/transactions/msgp_gen.go
index 218c86fa2..a487cc75c 100644
--- a/data/transactions/msgp_gen.go
+++ b/data/transactions/msgp_gen.go
@@ -2363,61 +2363,70 @@ func (z *Header) MsgIsZero() bool {
func (z *KeyregTxnFields) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0001Len := uint32(6)
- var zb0001Mask uint8 /* 7 bits */
- if (*z).Nonparticipation == false {
+ zb0001Len := uint32(7)
+ var zb0001Mask uint8 /* 8 bits */
+ if (*z).BlockProofPK.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x2
}
- if (*z).SelectionPK.MsgIsZero() {
+ if (*z).Nonparticipation == false {
zb0001Len--
zb0001Mask |= 0x4
}
- if (*z).VoteFirst.MsgIsZero() {
+ if (*z).SelectionPK.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x8
}
- if (*z).VoteKeyDilution == 0 {
+ if (*z).VoteFirst.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x10
}
- if (*z).VotePK.MsgIsZero() {
+ if (*z).VoteKeyDilution == 0 {
zb0001Len--
zb0001Mask |= 0x20
}
- if (*z).VoteLast.MsgIsZero() {
+ if (*z).VotePK.MsgIsZero() {
zb0001Len--
zb0001Mask |= 0x40
}
+ if (*z).VoteLast.MsgIsZero() {
+ zb0001Len--
+ zb0001Mask |= 0x80
+ }
// variable map header, size zb0001Len
o = append(o, 0x80|uint8(zb0001Len))
if zb0001Len != 0 {
if (zb0001Mask & 0x2) == 0 { // if not empty
+ // string "bprfkey"
+ o = append(o, 0xa7, 0x62, 0x70, 0x72, 0x66, 0x6b, 0x65, 0x79)
+ o = (*z).BlockProofPK.MarshalMsg(o)
+ }
+ if (zb0001Mask & 0x4) == 0 { // if not empty
// string "nonpart"
o = append(o, 0xa7, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74)
o = msgp.AppendBool(o, (*z).Nonparticipation)
}
- if (zb0001Mask & 0x4) == 0 { // if not empty
+ if (zb0001Mask & 0x8) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = (*z).SelectionPK.MarshalMsg(o)
}
- if (zb0001Mask & 0x8) == 0 { // if not empty
+ if (zb0001Mask & 0x10) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
o = (*z).VoteFirst.MarshalMsg(o)
}
- if (zb0001Mask & 0x10) == 0 { // if not empty
+ if (zb0001Mask & 0x20) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
o = msgp.AppendUint64(o, (*z).VoteKeyDilution)
}
- if (zb0001Mask & 0x20) == 0 { // if not empty
+ if (zb0001Mask & 0x40) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = (*z).VotePK.MarshalMsg(o)
}
- if (zb0001Mask & 0x40) == 0 { // if not empty
+ if (zb0001Mask & 0x80) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
o = (*z).VoteLast.MarshalMsg(o)
@@ -2462,6 +2471,14 @@ func (z *KeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
if zb0001 > 0 {
zb0001--
+ bts, err = (*z).BlockProofPK.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BlockProofPK")
+ return
+ }
+ }
+ if zb0001 > 0 {
+ zb0001--
bts, err = (*z).VoteFirst.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
@@ -2527,6 +2544,12 @@ func (z *KeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "SelectionPK")
return
}
+ case "bprfkey":
+ bts, err = (*z).BlockProofPK.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BlockProofPK")
+ return
+ }
case "votefst":
bts, err = (*z).VoteFirst.UnmarshalMsg(bts)
if err != nil {
@@ -2571,13 +2594,13 @@ func (_ *KeyregTxnFields) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *KeyregTxnFields) Msgsize() (s int) {
- s = 1 + 8 + (*z).VotePK.Msgsize() + 7 + (*z).SelectionPK.Msgsize() + 8 + (*z).VoteFirst.Msgsize() + 8 + (*z).VoteLast.Msgsize() + 7 + msgp.Uint64Size + 8 + msgp.BoolSize
+ s = 1 + 8 + (*z).VotePK.Msgsize() + 7 + (*z).SelectionPK.Msgsize() + 8 + (*z).BlockProofPK.Msgsize() + 8 + (*z).VoteFirst.Msgsize() + 8 + (*z).VoteLast.Msgsize() + 7 + msgp.Uint64Size + 8 + msgp.BoolSize
return
}
// MsgIsZero returns whether this is a zero value
func (z *KeyregTxnFields) MsgIsZero() bool {
- return ((*z).VotePK.MsgIsZero()) && ((*z).SelectionPK.MsgIsZero()) && ((*z).VoteFirst.MsgIsZero()) && ((*z).VoteLast.MsgIsZero()) && ((*z).VoteKeyDilution == 0) && ((*z).Nonparticipation == false)
+ return ((*z).VotePK.MsgIsZero()) && ((*z).SelectionPK.MsgIsZero()) && ((*z).BlockProofPK.MsgIsZero()) && ((*z).VoteFirst.MsgIsZero()) && ((*z).VoteLast.MsgIsZero()) && ((*z).VoteKeyDilution == 0) && ((*z).Nonparticipation == false)
}
// MarshalMsg implements msgp.Marshaler
@@ -4176,8 +4199,8 @@ func (z *SignedTxnWithAD) MsgIsZero() bool {
func (z *Transaction) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0006Len := uint32(44)
- var zb0006Mask uint64 /* 53 bits */
+ zb0006Len := uint32(45)
+ var zb0006Mask uint64 /* 54 bits */
if (*z).AssetTransferTxnFields.AssetAmount == 0 {
zb0006Len--
zb0006Mask |= 0x200
@@ -4250,110 +4273,114 @@ func (z *Transaction) MarshalMsg(b []byte) (o []byte) {
zb0006Len--
zb0006Mask |= 0x4000000
}
- if (*z).AssetConfigTxnFields.ConfigAsset.MsgIsZero() {
+ if (*z).KeyregTxnFields.BlockProofPK.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x8000000
}
- if (*z).CompactCertTxnFields.Cert.MsgIsZero() {
+ if (*z).AssetConfigTxnFields.ConfigAsset.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x10000000
}
- if (*z).CompactCertTxnFields.CertRound.MsgIsZero() {
+ if (*z).CompactCertTxnFields.Cert.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x20000000
}
- if (*z).CompactCertTxnFields.CertType.MsgIsZero() {
+ if (*z).CompactCertTxnFields.CertRound.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x40000000
}
- if (*z).PaymentTxnFields.CloseRemainderTo.MsgIsZero() {
+ if (*z).CompactCertTxnFields.CertType.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x80000000
}
- if (*z).AssetFreezeTxnFields.FreezeAccount.MsgIsZero() {
+ if (*z).PaymentTxnFields.CloseRemainderTo.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x100000000
}
- if (*z).AssetFreezeTxnFields.FreezeAsset.MsgIsZero() {
+ if (*z).AssetFreezeTxnFields.FreezeAccount.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x200000000
}
- if (*z).Header.Fee.MsgIsZero() {
+ if (*z).AssetFreezeTxnFields.FreezeAsset.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x400000000
}
- if (*z).Header.FirstValid.MsgIsZero() {
+ if (*z).Header.Fee.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x800000000
}
- if (*z).Header.GenesisID == "" {
+ if (*z).Header.FirstValid.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x1000000000
}
- if (*z).Header.GenesisHash.MsgIsZero() {
+ if (*z).Header.GenesisID == "" {
zb0006Len--
zb0006Mask |= 0x2000000000
}
- if (*z).Header.Group.MsgIsZero() {
+ if (*z).Header.GenesisHash.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x4000000000
}
- if (*z).Header.LastValid.MsgIsZero() {
+ if (*z).Header.Group.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x8000000000
}
- if (*z).Header.Lease == ([LeaseByteLength]byte{}) {
+ if (*z).Header.LastValid.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x10000000000
}
- if (*z).KeyregTxnFields.Nonparticipation == false {
+ if (*z).Header.Lease == ([LeaseByteLength]byte{}) {
zb0006Len--
zb0006Mask |= 0x20000000000
}
- if len((*z).Header.Note) == 0 {
+ if (*z).KeyregTxnFields.Nonparticipation == false {
zb0006Len--
zb0006Mask |= 0x40000000000
}
- if (*z).PaymentTxnFields.Receiver.MsgIsZero() {
+ if len((*z).Header.Note) == 0 {
zb0006Len--
zb0006Mask |= 0x80000000000
}
- if (*z).Header.RekeyTo.MsgIsZero() {
+ if (*z).PaymentTxnFields.Receiver.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x100000000000
}
- if (*z).KeyregTxnFields.SelectionPK.MsgIsZero() {
+ if (*z).Header.RekeyTo.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x200000000000
}
- if (*z).Header.Sender.MsgIsZero() {
+ if (*z).KeyregTxnFields.SelectionPK.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x400000000000
}
- if (*z).Type.MsgIsZero() {
+ if (*z).Header.Sender.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x800000000000
}
- if (*z).KeyregTxnFields.VoteFirst.MsgIsZero() {
+ if (*z).Type.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x1000000000000
}
- if (*z).KeyregTxnFields.VoteKeyDilution == 0 {
+ if (*z).KeyregTxnFields.VoteFirst.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x2000000000000
}
- if (*z).KeyregTxnFields.VotePK.MsgIsZero() {
+ if (*z).KeyregTxnFields.VoteKeyDilution == 0 {
zb0006Len--
zb0006Mask |= 0x4000000000000
}
- if (*z).KeyregTxnFields.VoteLast.MsgIsZero() {
+ if (*z).KeyregTxnFields.VotePK.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x8000000000000
}
- if (*z).AssetTransferTxnFields.XferAsset.MsgIsZero() {
+ if (*z).KeyregTxnFields.VoteLast.MsgIsZero() {
zb0006Len--
zb0006Mask |= 0x10000000000000
}
+ if (*z).AssetTransferTxnFields.XferAsset.MsgIsZero() {
+ zb0006Len--
+ zb0006Mask |= 0x20000000000000
+ }
// variable map header, size zb0006Len
o = msgp.AppendMapHeader(o, zb0006Len)
if zb0006Len != 0 {
@@ -4476,131 +4503,136 @@ func (z *Transaction) MarshalMsg(b []byte) (o []byte) {
o = (*z).AssetTransferTxnFields.AssetSender.MarshalMsg(o)
}
if (zb0006Mask & 0x8000000) == 0 { // if not empty
+ // string "bprfkey"
+ o = append(o, 0xa7, 0x62, 0x70, 0x72, 0x66, 0x6b, 0x65, 0x79)
+ o = (*z).KeyregTxnFields.BlockProofPK.MarshalMsg(o)
+ }
+ if (zb0006Mask & 0x10000000) == 0 { // if not empty
// string "caid"
o = append(o, 0xa4, 0x63, 0x61, 0x69, 0x64)
o = (*z).AssetConfigTxnFields.ConfigAsset.MarshalMsg(o)
}
- if (zb0006Mask & 0x10000000) == 0 { // if not empty
+ if (zb0006Mask & 0x20000000) == 0 { // if not empty
// string "cert"
o = append(o, 0xa4, 0x63, 0x65, 0x72, 0x74)
o = (*z).CompactCertTxnFields.Cert.MarshalMsg(o)
}
- if (zb0006Mask & 0x20000000) == 0 { // if not empty
+ if (zb0006Mask & 0x40000000) == 0 { // if not empty
// string "certrnd"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64)
o = (*z).CompactCertTxnFields.CertRound.MarshalMsg(o)
}
- if (zb0006Mask & 0x40000000) == 0 { // if not empty
+ if (zb0006Mask & 0x80000000) == 0 { // if not empty
// string "certtype"
o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65)
o = (*z).CompactCertTxnFields.CertType.MarshalMsg(o)
}
- if (zb0006Mask & 0x80000000) == 0 { // if not empty
+ if (zb0006Mask & 0x100000000) == 0 { // if not empty
// string "close"
o = append(o, 0xa5, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = (*z).PaymentTxnFields.CloseRemainderTo.MarshalMsg(o)
}
- if (zb0006Mask & 0x100000000) == 0 { // if not empty
+ if (zb0006Mask & 0x200000000) == 0 { // if not empty
// string "fadd"
o = append(o, 0xa4, 0x66, 0x61, 0x64, 0x64)
o = (*z).AssetFreezeTxnFields.FreezeAccount.MarshalMsg(o)
}
- if (zb0006Mask & 0x200000000) == 0 { // if not empty
+ if (zb0006Mask & 0x400000000) == 0 { // if not empty
// string "faid"
o = append(o, 0xa4, 0x66, 0x61, 0x69, 0x64)
o = (*z).AssetFreezeTxnFields.FreezeAsset.MarshalMsg(o)
}
- if (zb0006Mask & 0x400000000) == 0 { // if not empty
+ if (zb0006Mask & 0x800000000) == 0 { // if not empty
// string "fee"
o = append(o, 0xa3, 0x66, 0x65, 0x65)
o = (*z).Header.Fee.MarshalMsg(o)
}
- if (zb0006Mask & 0x800000000) == 0 { // if not empty
+ if (zb0006Mask & 0x1000000000) == 0 { // if not empty
// string "fv"
o = append(o, 0xa2, 0x66, 0x76)
o = (*z).Header.FirstValid.MarshalMsg(o)
}
- if (zb0006Mask & 0x1000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x2000000000) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).Header.GenesisID)
}
- if (zb0006Mask & 0x2000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x4000000000) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).Header.GenesisHash.MarshalMsg(o)
}
- if (zb0006Mask & 0x4000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x8000000000) == 0 { // if not empty
// string "grp"
o = append(o, 0xa3, 0x67, 0x72, 0x70)
o = (*z).Header.Group.MarshalMsg(o)
}
- if (zb0006Mask & 0x8000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x10000000000) == 0 { // if not empty
// string "lv"
o = append(o, 0xa2, 0x6c, 0x76)
o = (*z).Header.LastValid.MarshalMsg(o)
}
- if (zb0006Mask & 0x10000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x20000000000) == 0 { // if not empty
// string "lx"
o = append(o, 0xa2, 0x6c, 0x78)
o = msgp.AppendBytes(o, ((*z).Header.Lease)[:])
}
- if (zb0006Mask & 0x20000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x40000000000) == 0 { // if not empty
// string "nonpart"
o = append(o, 0xa7, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74)
o = msgp.AppendBool(o, (*z).KeyregTxnFields.Nonparticipation)
}
- if (zb0006Mask & 0x40000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x80000000000) == 0 { // if not empty
// string "note"
o = append(o, 0xa4, 0x6e, 0x6f, 0x74, 0x65)
o = msgp.AppendBytes(o, (*z).Header.Note)
}
- if (zb0006Mask & 0x80000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x100000000000) == 0 { // if not empty
// string "rcv"
o = append(o, 0xa3, 0x72, 0x63, 0x76)
o = (*z).PaymentTxnFields.Receiver.MarshalMsg(o)
}
- if (zb0006Mask & 0x100000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x200000000000) == 0 { // if not empty
// string "rekey"
o = append(o, 0xa5, 0x72, 0x65, 0x6b, 0x65, 0x79)
o = (*z).Header.RekeyTo.MarshalMsg(o)
}
- if (zb0006Mask & 0x200000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x400000000000) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = (*z).KeyregTxnFields.SelectionPK.MarshalMsg(o)
}
- if (zb0006Mask & 0x400000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x800000000000) == 0 { // if not empty
// string "snd"
o = append(o, 0xa3, 0x73, 0x6e, 0x64)
o = (*z).Header.Sender.MarshalMsg(o)
}
- if (zb0006Mask & 0x800000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x1000000000000) == 0 { // if not empty
// string "type"
o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
o = (*z).Type.MarshalMsg(o)
}
- if (zb0006Mask & 0x1000000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x2000000000000) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
o = (*z).KeyregTxnFields.VoteFirst.MarshalMsg(o)
}
- if (zb0006Mask & 0x2000000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x4000000000000) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
o = msgp.AppendUint64(o, (*z).KeyregTxnFields.VoteKeyDilution)
}
- if (zb0006Mask & 0x4000000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x8000000000000) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = (*z).KeyregTxnFields.VotePK.MarshalMsg(o)
}
- if (zb0006Mask & 0x8000000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x10000000000000) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
o = (*z).KeyregTxnFields.VoteLast.MarshalMsg(o)
}
- if (zb0006Mask & 0x10000000000000) == 0 { // if not empty
+ if (zb0006Mask & 0x20000000000000) == 0 { // if not empty
// string "xaid"
o = append(o, 0xa4, 0x78, 0x61, 0x69, 0x64)
o = (*z).AssetTransferTxnFields.XferAsset.MarshalMsg(o)
@@ -4743,6 +4775,14 @@ func (z *Transaction) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
if zb0006 > 0 {
zb0006--
+ bts, err = (*z).KeyregTxnFields.BlockProofPK.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BlockProofPK")
+ return
+ }
+ }
+ if zb0006 > 0 {
+ zb0006--
bts, err = (*z).KeyregTxnFields.VoteFirst.UnmarshalMsg(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
@@ -5208,6 +5248,12 @@ func (z *Transaction) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "SelectionPK")
return
}
+ case "bprfkey":
+ bts, err = (*z).KeyregTxnFields.BlockProofPK.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BlockProofPK")
+ return
+ }
case "votefst":
bts, err = (*z).KeyregTxnFields.VoteFirst.UnmarshalMsg(bts)
if err != nil {
@@ -5522,7 +5568,7 @@ func (_ *Transaction) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Transaction) Msgsize() (s int) {
- s = 3 + 5 + (*z).Type.Msgsize() + 4 + (*z).Header.Sender.Msgsize() + 4 + (*z).Header.Fee.Msgsize() + 3 + (*z).Header.FirstValid.Msgsize() + 3 + (*z).Header.LastValid.Msgsize() + 5 + msgp.BytesPrefixSize + len((*z).Header.Note) + 4 + msgp.StringPrefixSize + len((*z).Header.GenesisID) + 3 + (*z).Header.GenesisHash.Msgsize() + 4 + (*z).Header.Group.Msgsize() + 3 + msgp.ArrayHeaderSize + (LeaseByteLength * (msgp.ByteSize)) + 6 + (*z).Header.RekeyTo.Msgsize() + 8 + (*z).KeyregTxnFields.VotePK.Msgsize() + 7 + (*z).KeyregTxnFields.SelectionPK.Msgsize() + 8 + (*z).KeyregTxnFields.VoteFirst.Msgsize() + 8 + (*z).KeyregTxnFields.VoteLast.Msgsize() + 7 + msgp.Uint64Size + 8 + msgp.BoolSize + 4 + (*z).PaymentTxnFields.Receiver.Msgsize() + 4 + (*z).PaymentTxnFields.Amount.Msgsize() + 6 + (*z).PaymentTxnFields.CloseRemainderTo.Msgsize() + 5 + (*z).AssetConfigTxnFields.ConfigAsset.Msgsize() + 5 + (*z).AssetConfigTxnFields.AssetParams.Msgsize() + 5 + (*z).AssetTransferTxnFields.XferAsset.Msgsize() + 5 + msgp.Uint64Size + 5 + (*z).AssetTransferTxnFields.AssetSender.Msgsize() + 5 + (*z).AssetTransferTxnFields.AssetReceiver.Msgsize() + 7 + (*z).AssetTransferTxnFields.AssetCloseTo.Msgsize() + 5 + (*z).AssetFreezeTxnFields.FreezeAccount.Msgsize() + 5 + (*z).AssetFreezeTxnFields.FreezeAsset.Msgsize() + 5 + msgp.BoolSize + 5 + (*z).ApplicationCallTxnFields.ApplicationID.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.ArrayHeaderSize
+ s = 3 + 5 + (*z).Type.Msgsize() + 4 + (*z).Header.Sender.Msgsize() + 4 + (*z).Header.Fee.Msgsize() + 3 + (*z).Header.FirstValid.Msgsize() + 3 + (*z).Header.LastValid.Msgsize() + 5 + msgp.BytesPrefixSize + len((*z).Header.Note) + 4 + msgp.StringPrefixSize + len((*z).Header.GenesisID) + 3 + (*z).Header.GenesisHash.Msgsize() + 4 + (*z).Header.Group.Msgsize() + 3 + msgp.ArrayHeaderSize + (LeaseByteLength * (msgp.ByteSize)) + 6 + (*z).Header.RekeyTo.Msgsize() + 8 + (*z).KeyregTxnFields.VotePK.Msgsize() + 7 + (*z).KeyregTxnFields.SelectionPK.Msgsize() + 8 + (*z).KeyregTxnFields.BlockProofPK.Msgsize() + 8 + (*z).KeyregTxnFields.VoteFirst.Msgsize() + 8 + (*z).KeyregTxnFields.VoteLast.Msgsize() + 7 + msgp.Uint64Size + 8 + msgp.BoolSize + 4 + (*z).PaymentTxnFields.Receiver.Msgsize() + 4 + (*z).PaymentTxnFields.Amount.Msgsize() + 6 + (*z).PaymentTxnFields.CloseRemainderTo.Msgsize() + 5 + (*z).AssetConfigTxnFields.ConfigAsset.Msgsize() + 5 + (*z).AssetConfigTxnFields.AssetParams.Msgsize() + 5 + (*z).AssetTransferTxnFields.XferAsset.Msgsize() + 5 + msgp.Uint64Size + 5 + (*z).AssetTransferTxnFields.AssetSender.Msgsize() + 5 + (*z).AssetTransferTxnFields.AssetReceiver.Msgsize() + 7 + (*z).AssetTransferTxnFields.AssetCloseTo.Msgsize() + 5 + (*z).AssetFreezeTxnFields.FreezeAccount.Msgsize() + 5 + (*z).AssetFreezeTxnFields.FreezeAsset.Msgsize() + 5 + msgp.BoolSize + 5 + (*z).ApplicationCallTxnFields.ApplicationID.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.ArrayHeaderSize
for zb0002 := range (*z).ApplicationCallTxnFields.ApplicationArgs {
s += msgp.BytesPrefixSize + len((*z).ApplicationCallTxnFields.ApplicationArgs[zb0002])
}
@@ -5544,7 +5590,7 @@ func (z *Transaction) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *Transaction) MsgIsZero() bool {
- return ((*z).Type.MsgIsZero()) && ((*z).Header.Sender.MsgIsZero()) && ((*z).Header.Fee.MsgIsZero()) && ((*z).Header.FirstValid.MsgIsZero()) && ((*z).Header.LastValid.MsgIsZero()) && (len((*z).Header.Note) == 0) && ((*z).Header.GenesisID == "") && ((*z).Header.GenesisHash.MsgIsZero()) && ((*z).Header.Group.MsgIsZero()) && ((*z).Header.Lease == ([LeaseByteLength]byte{})) && ((*z).Header.RekeyTo.MsgIsZero()) && ((*z).KeyregTxnFields.VotePK.MsgIsZero()) && ((*z).KeyregTxnFields.SelectionPK.MsgIsZero()) && ((*z).KeyregTxnFields.VoteFirst.MsgIsZero()) && ((*z).KeyregTxnFields.VoteLast.MsgIsZero()) && ((*z).KeyregTxnFields.VoteKeyDilution == 0) && ((*z).KeyregTxnFields.Nonparticipation == false) && ((*z).PaymentTxnFields.Receiver.MsgIsZero()) && ((*z).PaymentTxnFields.Amount.MsgIsZero()) && ((*z).PaymentTxnFields.CloseRemainderTo.MsgIsZero()) && ((*z).AssetConfigTxnFields.ConfigAsset.MsgIsZero()) && ((*z).AssetConfigTxnFields.AssetParams.MsgIsZero()) && ((*z).AssetTransferTxnFields.XferAsset.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetAmount == 0) && ((*z).AssetTransferTxnFields.AssetSender.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetReceiver.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetCloseTo.MsgIsZero()) && ((*z).AssetFreezeTxnFields.FreezeAccount.MsgIsZero()) && ((*z).AssetFreezeTxnFields.FreezeAsset.MsgIsZero()) && ((*z).AssetFreezeTxnFields.AssetFrozen == false) && ((*z).ApplicationCallTxnFields.ApplicationID.MsgIsZero()) && ((*z).ApplicationCallTxnFields.OnCompletion == 0) && (len((*z).ApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).ApplicationCallTxnFields.Accounts) == 0) && (len((*z).ApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).ApplicationCallTxnFields.ForeignAssets) == 0) && ((*z).ApplicationCallTxnFields.LocalStateSchema.MsgIsZero()) && ((*z).ApplicationCallTxnFields.GlobalStateSchema.MsgIsZero()) && (len((*z).ApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).ApplicationCallTxnFields.ClearStateProgram) == 0) && ((*z).ApplicationCallTxnFields.ExtraProgramPages == 0) && ((*z).CompactCertTxnFields.CertRound.MsgIsZero()) && ((*z).CompactCertTxnFields.CertType.MsgIsZero()) && ((*z).CompactCertTxnFields.Cert.MsgIsZero())
+ return ((*z).Type.MsgIsZero()) && ((*z).Header.Sender.MsgIsZero()) && ((*z).Header.Fee.MsgIsZero()) && ((*z).Header.FirstValid.MsgIsZero()) && ((*z).Header.LastValid.MsgIsZero()) && (len((*z).Header.Note) == 0) && ((*z).Header.GenesisID == "") && ((*z).Header.GenesisHash.MsgIsZero()) && ((*z).Header.Group.MsgIsZero()) && ((*z).Header.Lease == ([LeaseByteLength]byte{})) && ((*z).Header.RekeyTo.MsgIsZero()) && ((*z).KeyregTxnFields.VotePK.MsgIsZero()) && ((*z).KeyregTxnFields.SelectionPK.MsgIsZero()) && ((*z).KeyregTxnFields.BlockProofPK.MsgIsZero()) && ((*z).KeyregTxnFields.VoteFirst.MsgIsZero()) && ((*z).KeyregTxnFields.VoteLast.MsgIsZero()) && ((*z).KeyregTxnFields.VoteKeyDilution == 0) && ((*z).KeyregTxnFields.Nonparticipation == false) && ((*z).PaymentTxnFields.Receiver.MsgIsZero()) && ((*z).PaymentTxnFields.Amount.MsgIsZero()) && ((*z).PaymentTxnFields.CloseRemainderTo.MsgIsZero()) && ((*z).AssetConfigTxnFields.ConfigAsset.MsgIsZero()) && ((*z).AssetConfigTxnFields.AssetParams.MsgIsZero()) && ((*z).AssetTransferTxnFields.XferAsset.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetAmount == 0) && ((*z).AssetTransferTxnFields.AssetSender.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetReceiver.MsgIsZero()) && ((*z).AssetTransferTxnFields.AssetCloseTo.MsgIsZero()) && ((*z).AssetFreezeTxnFields.FreezeAccount.MsgIsZero()) && ((*z).AssetFreezeTxnFields.FreezeAsset.MsgIsZero()) && ((*z).AssetFreezeTxnFields.AssetFrozen == false) && ((*z).ApplicationCallTxnFields.ApplicationID.MsgIsZero()) && ((*z).ApplicationCallTxnFields.OnCompletion == 0) && (len((*z).ApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).ApplicationCallTxnFields.Accounts) == 0) && (len((*z).ApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).ApplicationCallTxnFields.ForeignAssets) == 0) && ((*z).ApplicationCallTxnFields.LocalStateSchema.MsgIsZero()) && ((*z).ApplicationCallTxnFields.GlobalStateSchema.MsgIsZero()) && (len((*z).ApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).ApplicationCallTxnFields.ClearStateProgram) == 0) && ((*z).ApplicationCallTxnFields.ExtraProgramPages == 0) && ((*z).CompactCertTxnFields.CertRound.MsgIsZero()) && ((*z).CompactCertTxnFields.CertType.MsgIsZero()) && ((*z).CompactCertTxnFields.Cert.MsgIsZero())
}
// MarshalMsg implements msgp.Marshaler
diff --git a/data/transactions/transaction.go b/data/transactions/transaction.go
index baf40a312..adc270aef 100644
--- a/data/transactions/transaction.go
+++ b/data/transactions/transaction.go
@@ -20,6 +20,8 @@ import (
"errors"
"fmt"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
@@ -265,6 +267,10 @@ var errKeyregTxnUnsupportedSwitchToNonParticipating = errors.New("transaction tr
var errKeyregTxnGoingOnlineWithNonParticipating = errors.New("transaction tries to register keys to go online, but nonparticipatory flag is set")
var errKeyregTxnGoingOnlineWithZeroVoteLast = errors.New("transaction tries to register keys to go online, but vote last is set to zero")
var errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid = errors.New("transaction tries to register keys to go online, but first voting round is beyond the round after last valid round")
+var errKeyRegEmptyBlockProofPK = errors.New("online keyreg transaction cannot have empty field BlockProofPK")
+var errKeyregTxnNotEmptyBLockProofPK = errors.New("transaction field BlockProofPK should be empty in this consensus version")
+var errKeyregTxnNonParticipantShouldBeEmptyBlockProofPK = errors.New("non participation keyreg transactions should contain empty blockProofPK")
+var errKeyregTxnOfflineShouldBeEmptyBlockProofPK = errors.New("offline keyreg transactions should contain empty blockProofPK")
// WellFormed checks that the transaction looks reasonable on its own (but not necessarily valid against the actual ledger). It does not check signatures.
func (tx Transaction) WellFormed(spec SpecialAddresses, proto config.ConsensusParams) error {
@@ -321,6 +327,10 @@ func (tx Transaction) WellFormed(spec SpecialAddresses, proto config.ConsensusPa
}
+ if err := tx.blockProofPKWellFormed(proto); err != nil {
+ return err
+ }
+
case protocol.AssetConfigTx:
if !proto.Asset {
return fmt.Errorf("asset transaction not supported")
@@ -550,6 +560,40 @@ func (tx Transaction) WellFormed(spec SpecialAddresses, proto config.ConsensusPa
return nil
}
+func (tx Transaction) blockProofPKWellFormed(proto config.ConsensusParams) error {
+ isEmptyBlock := tx.KeyregTxnFields.BlockProofPK == merklekeystore.Verifier{}
+ if !proto.EnableBlockProofKeyregCheck {
+ // make certain empty key is stored.
+ if !isEmptyBlock {
+ return errKeyregTxnNotEmptyBLockProofPK
+ }
+ return nil
+ }
+
+ if tx.Nonparticipation {
+ // make certain that set offline request clears the blockProofPK.
+ if !isEmptyBlock {
+ return errKeyregTxnNonParticipantShouldBeEmptyBlockProofPK
+ }
+ return nil
+ }
+
+ if tx.VotePK == (crypto.OneTimeSignatureVerifier{}) || tx.SelectionPK == (crypto.VRFVerifier{}) {
+ if !isEmptyBlock {
+ return errKeyregTxnOfflineShouldBeEmptyBlockProofPK
+ }
+ return nil
+ }
+
+ // online transactions:
+ // setting online cannot set an empty blockProofPK
+ if isEmptyBlock {
+ return errKeyRegEmptyBlockProofPK
+ }
+
+ return nil
+}
+
// Aux returns the note associated with this transaction
func (tx Header) Aux() []byte {
return tx.Note
diff --git a/data/transactions/transaction_test.go b/data/transactions/transaction_test.go
index 72fe13b2f..14743ebb2 100644
--- a/data/transactions/transaction_test.go
+++ b/data/transactions/transaction_test.go
@@ -22,6 +22,8 @@ import (
"strings"
"testing"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
@@ -541,6 +543,7 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
type keyRegTestCase struct {
votePK crypto.OneTimeSignatureVerifier
selectionPK crypto.VRFVerifier
+ blockProofPK merklekeystore.Verifier
voteFirst basics.Round
voteLast basics.Round
lastValid basics.Round
@@ -548,12 +551,16 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
nonParticipation bool
supportBecomeNonParticipatingTransactions bool
enableKeyregCoherencyCheck bool
+ enableBlockProofKeyregCheck bool
err error
}
votePKValue := crypto.OneTimeSignatureVerifier{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
selectionPKValue := crypto.VRFVerifier{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
+ blockProofPK := merklekeystore.Verifier{Root: [merklekeystore.KeyStoreRootSize]byte{1}}
+
runTestCase := func(testCase keyRegTestCase) error {
+
tx.KeyregTxnFields.VotePK = testCase.votePK
tx.KeyregTxnFields.SelectionPK = testCase.selectionPK
tx.KeyregTxnFields.VoteFirst = testCase.voteFirst
@@ -561,9 +568,11 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
tx.KeyregTxnFields.VoteKeyDilution = testCase.voteKeyDilution
tx.KeyregTxnFields.Nonparticipation = testCase.nonParticipation
tx.LastValid = testCase.lastValid
+ tx.KeyregTxnFields.BlockProofPK = testCase.blockProofPK
curProto.SupportBecomeNonParticipatingTransactions = testCase.supportBecomeNonParticipatingTransactions
curProto.EnableKeyregCoherencyCheck = testCase.enableKeyregCoherencyCheck
+ curProto.EnableBlockProofKeyregCheck = testCase.enableBlockProofKeyregCheck
return tx.WellFormed(spec, curProto)
}
@@ -579,55 +588,59 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
for _, nonParticipation := range []bool{false, true} {
for _, supportBecomeNonParticipatingTransactions := range []bool{false, true} {
for _, enableKeyregCoherencyCheck := range []bool{false, true} {
- outcome := runTestCase(keyRegTestCase{
- votePK,
- selectionPK,
- voteFirst,
- voteLast,
- lastValid,
- voteKeyDilution,
- nonParticipation,
- supportBecomeNonParticipatingTransactions,
- enableKeyregCoherencyCheck,
- nil})
- errStr := "nil"
- switch outcome {
- case errKeyregTxnUnsupportedSwitchToNonParticipating:
- errStr = "errKeyregTxnUnsupportedSwitchToNonParticipating"
- case errKeyregTxnGoingOnlineWithNonParticipating:
- errStr = "errKeyregTxnGoingOnlineWithNonParticipating"
- case errKeyregTxnNonCoherentVotingKeys:
- errStr = "errKeyregTxnNonCoherentVotingKeys"
- case errKeyregTxnOfflineTransactionHasVotingRounds:
- errStr = "errKeyregTxnOfflineTransactionHasVotingRounds"
- case errKeyregTxnFirstVotingRoundGreaterThanLastVotingRound:
- errStr = "errKeyregTxnFirstVotingRoundGreaterThanLastVotingRound"
- case errKeyregTxnGoingOnlineWithZeroVoteLast:
- errStr = "errKeyregTxnGoingOnlineWithZeroVoteLast"
- case errKeyregTxnGoingOnlineWithNonParticipating:
- errStr = "errKeyregTxnGoingOnlineWithNonParticipating"
- case errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid:
- errStr = "errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid"
- default:
- require.Nil(t, outcome)
+ for _, enableBlockProofKeyregCheck := range []bool{false, true} {
+ outcome := runTestCase(keyRegTestCase{
+ votePK,
+ selectionPK,
+ blockProofPK,
+ voteFirst,
+ voteLast,
+ lastValid,
+ voteKeyDilution,
+ nonParticipation,
+ supportBecomeNonParticipatingTransactions,
+ enableKeyregCoherencyCheck,
+ enableBlockProofKeyregCheck,
+ nil})
+ errStr := "nil"
+ switch outcome {
+ case errKeyregTxnUnsupportedSwitchToNonParticipating:
+ errStr = "errKeyregTxnUnsupportedSwitchToNonParticipating"
+ case errKeyregTxnGoingOnlineWithNonParticipating:
+ errStr = "errKeyregTxnGoingOnlineWithNonParticipating"
+ case errKeyregTxnNonCoherentVotingKeys:
+ errStr = "errKeyregTxnNonCoherentVotingKeys"
+ case errKeyregTxnOfflineTransactionHasVotingRounds:
+ errStr = "errKeyregTxnOfflineTransactionHasVotingRounds"
+ case errKeyregTxnFirstVotingRoundGreaterThanLastVotingRound:
+ errStr = "errKeyregTxnFirstVotingRoundGreaterThanLastVotingRound"
+ case errKeyregTxnGoingOnlineWithZeroVoteLast:
+ errStr = "errKeyregTxnGoingOnlineWithZeroVoteLast"
+ case errKeyregTxnGoingOnlineWithNonParticipating:
+ errStr = "errKeyregTxnGoingOnlineWithNonParticipating"
+ case errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid:
+ errStr = "errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid"
+ default:
+ require.Nil(t, outcome)
+ }
+ s := "/* %3d */ keyRegTestCase{votePK:"
+ if votePK == votePKValue {
+ s += "votePKValue"
+ } else {
+ s += "crypto.OneTimeSignatureVerifier{}"
+ }
+ s += ", selectionPK:"
+ if selectionPK == selectionPKValue {
+ s += "selectionPKValue"
+ } else {
+ s += "crypto.VRFVerifier{}"
+ }
+ s = fmt.Sprintf("%s, voteFirst:basics.Round(%2d), voteLast:basics.Round(%2d), lastValid:basics.Round(%2d), voteKeyDilution: %5d, nonParticipation: %v,supportBecomeNonParticipatingTransactions:%v, enableKeyregCoherencyCheck:%v, err:%s},\n",
+ s, voteFirst, voteLast, lastValid, voteKeyDilution, nonParticipation, supportBecomeNonParticipatingTransactions, enableKeyregCoherencyCheck, errStr)
+ fmt.Printf(s, idx)
+ idx++
}
- s := "/* %3d */ keyRegTestCase{votePK:"
- if votePK == votePKValue {
- s += "votePKValue"
- } else {
- s += "crypto.OneTimeSignatureVerifier{}"
- }
- s += ", selectionPK:"
- if selectionPK == selectionPKValue {
- s += "selectionPKValue"
- } else {
- s += "crypto.VRFVerifier{}"
- }
- s = fmt.Sprintf("%s, voteFirst:basics.Round(%2d), voteLast:basics.Round(%2d), lastValid:basics.Round(%2d), voteKeyDilution: %5d, nonParticipation: %v,supportBecomeNonParticipatingTransactions:%v, enableKeyregCoherencyCheck:%v, err:%s},\n",
- s, voteFirst, voteLast, lastValid, voteKeyDilution, nonParticipation, supportBecomeNonParticipatingTransactions, enableKeyregCoherencyCheck, errStr)
- fmt.Printf(s, idx)
- idx++
}
}
}
@@ -1153,6 +1166,15 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
/* 509 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: false, enableKeyregCoherencyCheck: true, err: errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid},
/* 510 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, err: errKeyregTxnGoingOnlineWithNonParticipating},
/* 511 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: true, err: errKeyregTxnGoingOnlineWithFirstVoteAfterLastValid},
+ /* 512 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, blockProofPK: blockProofPK, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: false, err: errKeyregTxnNotEmptyBLockProofPK},
+ /* 513 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, blockProofPK: merklekeystore.Verifier{}, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: false, err: nil},
+ /* 514 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, blockProofPK: blockProofPK, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: nil},
+ /* 515 */ keyRegTestCase{votePK: votePKValue, selectionPK: selectionPKValue, blockProofPK: merklekeystore.Verifier{}, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: errKeyRegEmptyBlockProofPK},
+ /* 516 */ keyRegTestCase{votePK: crypto.OneTimeSignatureVerifier{}, selectionPK: crypto.VRFVerifier{}, blockProofPK: blockProofPK, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: errKeyregTxnNonParticipantShouldBeEmptyBlockProofPK},
+ /* 517 */ keyRegTestCase{votePK: crypto.OneTimeSignatureVerifier{}, selectionPK: crypto.VRFVerifier{}, blockProofPK: merklekeystore.Verifier{}, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: nil},
+ /* 518 */ keyRegTestCase{votePK: crypto.OneTimeSignatureVerifier{}, selectionPK: crypto.VRFVerifier{}, blockProofPK: blockProofPK, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: errKeyregTxnOfflineShouldBeEmptyBlockProofPK},
+ /* 519 */ keyRegTestCase{votePK: crypto.OneTimeSignatureVerifier{}, selectionPK: crypto.VRFVerifier{}, blockProofPK: merklekeystore.Verifier{}, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 10000, nonParticipation: true, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: nil},
+ /* 520 */ keyRegTestCase{votePK: crypto.OneTimeSignatureVerifier{}, selectionPK: crypto.VRFVerifier{}, blockProofPK: merklekeystore.Verifier{}, voteFirst: basics.Round(5), voteLast: basics.Round(10), lastValid: basics.Round(3), voteKeyDilution: 0, nonParticipation: false, supportBecomeNonParticipatingTransactions: true, enableKeyregCoherencyCheck: false, enableBlockProofKeyregCheck: true, err: nil},
}
for testcaseIdx, testCase := range keyRegTestCases {
err := runTestCase(testCase)
diff --git a/gen/generate.go b/gen/generate.go
index 08c2e373c..a8eaa4eb2 100644
--- a/gen/generate.go
+++ b/gen/generate.go
@@ -267,6 +267,9 @@ func generateGenesisFiles(outDir string, protoVersion protocol.ConsensusVersion,
data.VoteFirstValid = part.FirstValid
data.VoteLastValid = part.LastValid
data.VoteKeyDilution = part.KeyDilution
+ if config.Consensus[protocol.ConsensusFuture].EnableBlockProofKeyregCheck {
+ data.BlockProofID = *part.BlockProofSigner().GetVerifier()
+ }
}
writeMu.Lock()
diff --git a/gen/walletData.go b/gen/walletData.go
index 15cfd1f1d..93bc5bebe 100644
--- a/gen/walletData.go
+++ b/gen/walletData.go
@@ -28,7 +28,7 @@ import (
// instance (because we have no ctors...)
var DefaultGenesis = GenesisData{
FirstPartKeyRound: 0,
- LastPartKeyRound: 3000000,
+ LastPartKeyRound: 3000,
}
// WalletData represents a wallet's name, percent stake, and initial online status for a genesis.json file
diff --git a/go.mod b/go.mod
index 2ecfb9903..a67dc7439 100644
--- a/go.mod
+++ b/go.mod
@@ -3,6 +3,8 @@ module github.com/algorand/go-algorand
go 1.14
require (
+ github.com/algonathan/sumhash v0.0.0-20210902064122-c2f95258d5f3
+ github.com/algorand/dilithium v0.0.0-20210811122002-1ca237b9c9ac
github.com/algorand/go-codec/codec v0.0.0-20190507210007-269d70b6135d
github.com/algorand/go-deadlock v0.2.1
github.com/algorand/graphtrace v0.0.0-20201117160756-e524ed1a6f64
@@ -12,45 +14,27 @@ require (
github.com/algorand/xorfilter v0.2.0
github.com/aws/aws-sdk-go v1.16.5
github.com/chrismcguire/gobberish v0.0.0-20150821175641-1d8adb509a0e
- github.com/cpuguy83/go-md2man v1.0.8 // indirect
github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018
github.com/dchest/siphash v1.2.1
github.com/fatih/color v1.7.0
- github.com/fortytw2/leaktest v1.3.0 // indirect
github.com/gen2brain/beeep v0.0.0-20180718162406-4e430518395f
github.com/getkin/kin-openapi v0.22.0
- github.com/godbus/dbus v0.0.0-20181101234600-2ff6f7ffd60f // indirect
github.com/gofrs/flock v0.7.0
github.com/google/go-querystring v1.0.0
- github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e // indirect
- github.com/gopherjs/gopherwasm v1.0.1 // indirect
- github.com/gorilla/context v1.1.1 // indirect
github.com/gorilla/mux v1.6.2
- github.com/gorilla/schema v1.0.2
- github.com/gorilla/websocket v1.4.2 // indirect
- github.com/inconshreveable/mousetrap v1.0.0 // indirect
github.com/jmoiron/sqlx v1.2.0
github.com/karalabe/hid v1.0.0
github.com/labstack/echo/v4 v4.1.17
- github.com/mailru/easyjson v0.7.7 // indirect
github.com/mattn/go-sqlite3 v1.10.0
github.com/miekg/dns v1.1.27
- github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
- github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
github.com/olivere/elastic v6.2.14+incompatible
- github.com/russross/blackfriday v1.5.2 // indirect
github.com/satori/go.uuid v1.2.0
github.com/sirupsen/logrus v1.4.2
github.com/spf13/cobra v0.0.3
- github.com/spf13/pflag v1.0.5 // indirect
github.com/stretchr/testify v1.6.1
- golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a
- golang.org/x/net v0.0.0-20200904194848-62affa334b73
- golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208 // indirect
- golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f
- google.golang.org/appengine v1.6.7 // indirect
- gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+ golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
+ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
+ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
+ golang.org/x/sys v0.0.0-20210902050250-f475640dd07b
gopkg.in/sohlich/elogrus.v3 v3.0.0-20180410122755-1fa29e2f2009
- gopkg.in/toast.v1 v1.0.0-20180812000517-0a84660828b2 // indirect
- gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect
)
diff --git a/go.sum b/go.sum
index c5e86d8ce..94b8fa4b8 100644
--- a/go.sum
+++ b/go.sum
@@ -1,3 +1,8 @@
+github.com/algonathan/sumhash v0.0.0-20210902064122-c2f95258d5f3 h1:k3NpR7zWChaXtbLedjCE8g+N+HWZrp0bsTYOI0DgZEg=
+github.com/algonathan/sumhash v0.0.0-20210902064122-c2f95258d5f3/go.mod h1:o3SSyNw1Njyqx5pFdH4e8wZ7QK8xAwGXl6QKPzHrAFo=
+github.com/algorand/dilithium v0.0.0-20210811122002-1ca237b9c9ac h1:51AFAr+DP6/Dy80Q2n20UdTNImDvDym1F3N60/s/LYs=
+github.com/algorand/dilithium v0.0.0-20210811122002-1ca237b9c9ac/go.mod h1:uiTvM2HaPUdw/OcY7iZCQULVHzNN2oza0ICjm6fP4U8=
+github.com/algorand/go-algorand v0.0.0-20210810215942-dd7f7b6410af/go.mod h1:OHgE11gypiNBPQzngOs/JU314IjDNMx6R8t9iAWt47g=
github.com/algorand/go-codec v1.1.2 h1:QWS9YC3EEWBpJq5AqFPELcCJ2QPpTIg9aqR2K/sRDq4=
github.com/algorand/go-codec v1.1.2/go.mod h1:A3YI4V24jUUnU1eNekNmx2fLi60FvlNssqOiUsyfNM8=
github.com/algorand/go-codec/codec v0.0.0-20190507210007-269d70b6135d h1:W9MgGUodEl4Y4+CxeEr+T3fZ26kOcWA4yfqhjbFxxmI=
@@ -65,6 +70,7 @@ github.com/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA=
github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/karalabe/hid v0.0.0-20181128192157-d815e0c1a2e2/go.mod h1:YvbcH+3Wo6XPs9nkgTY3u19KXLauXW+J5nB7hEHuX0A=
github.com/karalabe/hid v1.0.0 h1:+/CIMNXhSU/zIJgnIvBD2nKHxS/bnRHhhs9xBryLpPo=
github.com/karalabe/hid v1.0.0/go.mod h1:Vr51f8rUOLYrfrWDFlV12GGQgM5AT8sVh+2fY4MPeu8=
github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
@@ -138,6 +144,10 @@ golang.org/x/crypto v0.0.0-20200414173820-0848c9571904/go.mod h1:LzIPMQfyMNhhGPh
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a h1:vclmkQCjlDX5OydZ9wv8rBCcS0QyQY66Mpf/7BZbInM=
golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210813211128-0a44fdfbc16e h1:VvfwVmMH40bpMeizC9/K7ipM5Qjucuu16RWfneFPyhQ=
+golang.org/x/crypto v0.0.0-20210813211128-0a44fdfbc16e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -149,9 +159,14 @@ golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/
golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200904194848-62affa334b73 h1:MXfv8rhZWmFeqX3GNZRsd6vOLoaCHjYEX3qkRo3YBUA=
golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -165,6 +180,14 @@ golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7w
golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f h1:Fqb3ao1hUmOR3GkUOg/Y+BadLwykBIzs5q8Ez2SbHyc=
golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210902050250-f475640dd07b h1:S7hKs0Flbq0bbc9xgYt4stIEG1zNDFqyrPwAX2Wj/sE=
+golang.org/x/sys v0.0.0-20210902050250-f475640dd07b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
diff --git a/ledger/accountdb.go b/ledger/accountdb.go
index f2f57efe8..8de738472 100644
--- a/ledger/accountdb.go
+++ b/ledger/accountdb.go
@@ -688,10 +688,9 @@ func accountDataToOnline(address basics.Address, ad *basics.AccountData, proto c
MicroAlgos: ad.MicroAlgos,
RewardsBase: ad.RewardsBase,
NormalizedOnlineBalance: ad.NormalizedOnlineBalance(proto),
- VoteID: ad.VoteID,
VoteFirstValid: ad.VoteFirstValid,
VoteLastValid: ad.VoteLastValid,
- VoteKeyDilution: ad.VoteKeyDilution,
+ BlockProofID: ad.BlockProofID,
}
}
diff --git a/ledger/accountdb_test.go b/ledger/accountdb_test.go
index 36d245ef6..b1b1d96d2 100644
--- a/ledger/accountdb_test.go
+++ b/ledger/accountdb_test.go
@@ -29,6 +29,8 @@ import (
"testing"
"time"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/stretchr/testify/require"
"github.com/algorand/go-algorand/config"
@@ -275,6 +277,55 @@ func TestAccountDBRound(t *testing.T) {
}
}
+func TestAccountStorageWithBlockProofID(t *testing.T) {
+ proto := config.Consensus[protocol.ConsensusFuture]
+
+ dbs, _ := dbOpenTest(t, true)
+ setDbLogging(t, dbs)
+ defer dbs.Close()
+
+ tx, err := dbs.Wdb.Handle.Begin()
+ require.NoError(t, err)
+ defer tx.Rollback()
+
+ accts := ledgertesting.RandomAccounts(20, false)
+ _, err = accountsInit(tx, accts, proto)
+ require.NoError(t, err)
+ checkAccounts(t, tx, 0, accts)
+ require.True(t, allAccountsHaveBlockProofPKs(accts))
+
+ var baseAccounts lruAccounts
+ baseAccounts.init(nil, 100, 80)
+
+ var updates ledgercore.AccountDeltas
+ var newaccts map[basics.Address]basics.AccountData
+ updates, newaccts, _, _ = ledgertesting.RandomDeltasFull(20, accts, 0, 0)
+ accts = newaccts
+
+ updatesCnt := makeCompactAccountDeltas([]ledgercore.AccountDeltas{updates}, baseAccounts)
+ err = updatesCnt.accountsLoadOld(tx)
+ require.NoError(t, err)
+ err = totalsNewRounds(tx, []ledgercore.AccountDeltas{updates}, updatesCnt, []ledgercore.AccountTotals{{}}, proto)
+ require.NoError(t, err)
+ _, err = accountsNewRound(tx, updatesCnt, nil, proto, basics.Round(0))
+ require.NoError(t, err)
+ err = updateAccountsRound(tx, basics.Round(1), 0)
+ require.NoError(t, err)
+ checkAccounts(t, tx, basics.Round(1), accts)
+ accounts, err := accountsAll(tx)
+ require.True(t, allAccountsHaveBlockProofPKs(accounts))
+ require.Equal(t, accts, accounts)
+}
+
+func allAccountsHaveBlockProofPKs(accts map[basics.Address]basics.AccountData) bool {
+ for _, data := range accts {
+ if data.BlockProofID == (merklekeystore.Verifier{}) {
+ return false
+ }
+ }
+ return true
+}
+
// checkCreatables compares the expected database image to the actual databse content
func checkCreatables(t *testing.T,
tx *sql.Tx, iteration int,
@@ -482,7 +533,7 @@ func benchmarkReadingAllBalances(b *testing.B, inMemory bool) {
prevHash := crypto.Digest{}
for _, accountBalance := range bal {
encodedAccountBalance := protocol.Encode(&accountBalance)
- prevHash = crypto.Hash(append(encodedAccountBalance, ([]byte(prevHash[:]))...))
+ prevHash = crypto.Hash(append(encodedAccountBalance, []byte(prevHash[:])...))
}
require.Equal(b, b.N, len(bal))
}
diff --git a/ledger/apply/keyreg.go b/ledger/apply/keyreg.go
index 532bfac51..94f15cda8 100644
--- a/ledger/apply/keyreg.go
+++ b/ledger/apply/keyreg.go
@@ -76,6 +76,9 @@ func Keyreg(keyreg transactions.KeyregTxnFields, header transactions.Header, bal
record.VoteFirstValid = keyreg.VoteFirst
record.VoteLastValid = keyreg.VoteLast
record.VoteKeyDilution = keyreg.VoteKeyDilution
+ if balances.ConsensusParams().EnableBlockProofKeyregCheck {
+ record.BlockProofID = keyreg.BlockProofPK
+ }
}
// Write the updated entry
diff --git a/ledger/apply/keyreg_test.go b/ledger/apply/keyreg_test.go
index ecb4e9072..3488a9e2d 100644
--- a/ledger/apply/keyreg_test.go
+++ b/ledger/apply/keyreg_test.go
@@ -19,6 +19,8 @@ package apply
import (
"testing"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
@@ -90,21 +92,7 @@ func TestKeyregApply(t *testing.T) {
vrfSecrets := crypto.GenerateVRFSecrets()
secretParticipation := keypair()
- tx := transactions.Transaction{
- Type: protocol.KeyRegistrationTx,
- Header: transactions.Header{
- Sender: src,
- Fee: basics.MicroAlgos{Raw: 1},
- FirstValid: basics.Round(100),
- LastValid: basics.Round(1000),
- },
- KeyregTxnFields: transactions.KeyregTxnFields{
- VotePK: crypto.OneTimeSignatureVerifier(secretParticipation.SignatureVerifier),
- SelectionPK: vrfSecrets.PK,
- VoteFirst: 0,
- VoteLast: 100,
- },
- }
+ tx := createTestTxn(t, src, secretParticipation, vrfSecrets)
err := Keyreg(tx.KeyregTxnFields, tx.Header, makeMockBalances(protocol.ConsensusCurrentVersion), transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
require.NoError(t, err)
@@ -173,5 +161,64 @@ func TestKeyregApply(t *testing.T) {
err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1100))
require.NoError(t, err)
+
+ testBlockProofPKBeingStored(t, tx, mockBal)
+ }
+}
+
+func testBlockProofPKBeingStored(t *testing.T, tx transactions.Transaction, mockBal keyregTestBalances) {
+ err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1100))
+ require.NoError(t, err) // expects no error with empty keyRegistration attempt
+
+ rec, err := mockBal.Get(tx.Header.Sender, false)
+ require.NoError(t, err) // expects no error with empty keyRegistration attempt
+ require.Equal(t, tx.KeyregTxnFields.BlockProofPK, rec.BlockProofID)
+}
+
+func TestBlockProofPKKeyReg(t *testing.T) {
+ partitiontest.PartitionTest(t)
+
+ secretSrc := keypair()
+ src := basics.Address(secretSrc.SignatureVerifier)
+ vrfSecrets := crypto.GenerateVRFSecrets()
+ secretParticipation := keypair()
+
+ tx := createTestTxn(t, src, secretParticipation, vrfSecrets)
+ mockBal := makeMockBalances(protocol.ConsensusCurrentVersion)
+ err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ require.NoError(t, err)
+
+ acct, err := mockBal.Get(tx.Src(), false)
+ require.NoError(t, err)
+ require.Equal(t, merklekeystore.Verifier{}, acct.BlockProofID)
+
+ mockBal = makeMockBalances(protocol.ConsensusFuture)
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ require.NoError(t, err)
+
+ acct, err = mockBal.Get(tx.Src(), false)
+ require.NoError(t, err)
+ require.NotEqual(t, merklekeystore.Verifier{}, acct.BlockProofID)
+}
+
+func createTestTxn(t *testing.T, src basics.Address, secretParticipation *crypto.SignatureSecrets, vrfSecrets *crypto.VRFSecrets) transactions.Transaction {
+ signer, err := merklekeystore.New(0, 0, 1, crypto.DilithiumType)
+ require.NoError(t, err)
+
+ return transactions.Transaction{
+ Type: protocol.KeyRegistrationTx,
+ Header: transactions.Header{
+ Sender: src,
+ Fee: basics.MicroAlgos{Raw: 1},
+ FirstValid: basics.Round(100),
+ LastValid: basics.Round(1000),
+ },
+ KeyregTxnFields: transactions.KeyregTxnFields{
+ VotePK: crypto.OneTimeSignatureVerifier(secretParticipation.SignatureVerifier),
+ SelectionPK: vrfSecrets.PK,
+ BlockProofPK: *signer.GetVerifier(),
+ VoteFirst: 0,
+ VoteLast: 100,
+ },
}
}
diff --git a/ledger/internal/compactcert.go b/ledger/internal/compactcert.go
index 2f90c8b22..330918d21 100644
--- a/ledger/internal/compactcert.go
+++ b/ledger/internal/compactcert.go
@@ -132,10 +132,11 @@ func CompactCertParams(votersHdr bookkeeping.BlockHeader, hdr bookkeeping.BlockH
}
res = compactcert.Params{
- Msg: hdr,
- ProvenWeight: provenWeight,
- SigRound: hdr.Round + 1,
- SecKQ: proto.CompactCertSecKQ,
+ Msg: hdr,
+ ProvenWeight: provenWeight,
+ SigRound: hdr.Round,
+ SecKQ: proto.CompactCertSecKQ,
+ CompactCertRounds: proto.CompactCertRounds,
}
return
}
diff --git a/ledger/internal/compactcert_test.go b/ledger/internal/compactcert_test.go
index 690d49375..0d37064f5 100644
--- a/ledger/internal/compactcert_test.go
+++ b/ledger/internal/compactcert_test.go
@@ -169,7 +169,7 @@ func TestCompactCertParams(t *testing.T) {
hdr.Round = 4
res, err = CompactCertParams(votersHdr, hdr)
- require.Equal(t, hdr.Round+1, res.SigRound)
+ require.Equal(t, hdr.Round, res.SigRound)
// Covers all cases except overflow
}
diff --git a/ledger/internal/eval.go b/ledger/internal/eval.go
index bc9af21b6..17ab5a278 100644
--- a/ledger/internal/eval.go
+++ b/ledger/internal/eval.go
@@ -1024,7 +1024,7 @@ func (eval *BlockEvaluator) applyTransaction(tx transactions.Transaction, balanc
// compactCertVotersAndTotal returns the expected values of CompactCertVoters
// and CompactCertVotersTotal for a block.
-func (eval *BlockEvaluator) compactCertVotersAndTotal() (root crypto.Digest, total basics.MicroAlgos, err error) {
+func (eval *BlockEvaluator) compactCertVotersAndTotal() (root crypto.GenericDigest, total basics.MicroAlgos, err error) {
if eval.proto.CompactCertRounds == 0 {
return
}
@@ -1241,7 +1241,7 @@ func (eval *BlockEvaluator) finalValidation() error {
if err != nil {
return err
}
- if eval.block.CompactCert[protocol.CompactCertBasic].CompactCertVoters != expectedVoters {
+ if !eval.block.CompactCert[protocol.CompactCertBasic].CompactCertVoters.IsEqual(expectedVoters) {
return fmt.Errorf("CompactCertVoters wrong: %v != %v", eval.block.CompactCert[protocol.CompactCertBasic].CompactCertVoters, expectedVoters)
}
if eval.block.CompactCert[protocol.CompactCertBasic].CompactCertVotersTotal != expectedVotersWeight {
diff --git a/ledger/ledger_test.go b/ledger/ledger_test.go
index 623c71c8f..0cd23dbbb 100644
--- a/ledger/ledger_test.go
+++ b/ledger/ledger_test.go
@@ -25,6 +25,8 @@ import (
"runtime/pprof"
"testing"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
+
"github.com/stretchr/testify/require"
"github.com/algorand/go-algorand/agreement"
@@ -1080,6 +1082,17 @@ func testLedgerSingleTxApplyData(t *testing.T, version protocol.ConsensusVersion
VoteLast: 10000,
}
+ // depends on what the concensus is need to generate correct KeyregTxnFields.
+ if proto.EnableBlockProofKeyregCheck {
+ frst, lst := uint64(correctKeyregFields.VoteFirst), uint64(correctKeyregFields.VoteLast)
+ signer, err := merklekeystore.New(frst, lst, 1, crypto.Ed25519Type)
+ require.NoError(t, err)
+
+ correctKeyregFields.BlockProofPK = *(signer.GetVerifier())
+ } else {
+ correctKeyregFields.BlockProofPK = merklekeystore.Verifier{}
+ }
+
correctKeyreg := transactions.Transaction{
Type: protocol.KeyRegistrationTx,
Header: correctTxHeader,
diff --git a/ledger/ledgercore/misc.go b/ledger/ledgercore/misc.go
index f4fd21f50..e75fc9049 100644
--- a/ledger/ledgercore/misc.go
+++ b/ledger/ledgercore/misc.go
@@ -30,17 +30,17 @@ import (
type ParticipantsArray []basics.Participant
// Length returns the ledger of the array.
-func (a ParticipantsArray) Length() uint64 {
- return uint64(len(a))
+func (p ParticipantsArray) Length() uint64 {
+ return uint64(len(p))
}
-// GetHash returns the hash for the given position.
-func (a ParticipantsArray) GetHash(pos uint64) (crypto.Digest, error) {
- if pos >= uint64(len(a)) {
- return crypto.Digest{}, fmt.Errorf("array ParticipantsArray.Get(%d) out of bounds %d", pos, len(a))
+// Marshal Returns the hash for the given position.
+func (p ParticipantsArray) Marshal(pos uint64) ([]byte, error) {
+ if pos >= uint64(len(p)) {
+ return crypto.GenericDigest{}, fmt.Errorf("array ParticipantsArray.Get(%d) out of bounds %d", pos, len(p))
}
- return crypto.HashObj(a[pos]), nil
+ return crypto.HashRep(p[pos]), nil
}
// InitState structure defines blockchain init params
diff --git a/ledger/ledgercore/onlineacct.go b/ledger/ledgercore/onlineacct.go
index de786e9be..22539052e 100644
--- a/ledger/ledgercore/onlineacct.go
+++ b/ledger/ledgercore/onlineacct.go
@@ -17,7 +17,7 @@
package ledgercore
import (
- "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
)
@@ -31,8 +31,7 @@ type OnlineAccount struct {
MicroAlgos basics.MicroAlgos
RewardsBase uint64
NormalizedOnlineBalance uint64
- VoteID crypto.OneTimeSignatureVerifier
VoteFirstValid basics.Round
VoteLastValid basics.Round
- VoteKeyDilution uint64
+ BlockProofID merklekeystore.Verifier
}
diff --git a/ledger/ledgercore/votersForRound.go b/ledger/ledgercore/votersForRound.go
index de76d2d29..4f1f109b5 100644
--- a/ledger/ledgercore/votersForRound.go
+++ b/ledger/ledgercore/votersForRound.go
@@ -18,6 +18,8 @@ package ledgercore
import (
"fmt"
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/compactcert"
"sync"
"github.com/algorand/go-deadlock"
@@ -112,20 +114,15 @@ func (tr *VotersForRound) LoadTree(onlineTop TopOnlineAccounts, hdr bookkeeping.
return fmt.Errorf("votersTracker.LoadTree: overflow computing totalWeight %d + %d", totalWeight.ToUint64(), money.ToUint64())
}
- keyDilution := acct.VoteKeyDilution
- if keyDilution == 0 {
- keyDilution = tr.Proto.DefaultKeyDilution
- }
-
participants[i] = basics.Participant{
- PK: acct.VoteID,
- Weight: money.ToUint64(),
- KeyDilution: keyDilution,
+ PK: acct.BlockProofID,
+ Weight: money.ToUint64(),
+ FirstValid: uint64(acct.VoteFirstValid),
}
addrToPos[acct.Address] = uint64(i)
}
- tree, err := merklearray.Build(participants)
+ tree, err := merklearray.Build(participants, crypto.HashFactory{HashType: compactcert.HashType})
if err != nil {
return err
}
diff --git a/ledger/testing/randomAccounts.go b/ledger/testing/randomAccounts.go
index 86ec6a60c..791aa4cb8 100644
--- a/ledger/testing/randomAccounts.go
+++ b/ledger/testing/randomAccounts.go
@@ -73,6 +73,7 @@ func RandomFullAccountData(rewardsLevel, lastCreatableID uint64) (basics.Account
crypto.RandBytes(data.VoteID[:])
crypto.RandBytes(data.SelectionID[:])
+ crypto.RandBytes(data.BlockProofID.Root[:])
data.VoteFirstValid = basics.Round(crypto.RandUint64())
data.VoteLastValid = basics.Round(crypto.RandUint64())
data.VoteKeyDilution = crypto.RandUint64()
@@ -84,7 +85,7 @@ func RandomFullAccountData(rewardsLevel, lastCreatableID uint64) (basics.Account
ap := basics.AssetParams{
Total: crypto.RandUint64(),
Decimals: uint32(crypto.RandUint64() % 20),
- DefaultFrozen: (crypto.RandUint64()%2 == 0),
+ DefaultFrozen: crypto.RandUint64()%2 == 0,
UnitName: fmt.Sprintf("un%x", uint32(crypto.RandUint64()%0x7fffffff)),
AssetName: fmt.Sprintf("an%x", uint32(crypto.RandUint64()%0x7fffffff)),
URL: fmt.Sprintf("url%x", uint32(crypto.RandUint64()%0x7fffffff)),
@@ -105,7 +106,7 @@ func RandomFullAccountData(rewardsLevel, lastCreatableID uint64) (basics.Account
for i := uint64(0); i < ownedAssetsCount; i++ {
ah := basics.AssetHolding{
Amount: crypto.RandUint64(),
- Frozen: (crypto.RandUint64()%2 == 0),
+ Frozen: crypto.RandUint64()%2 == 0,
}
data.Assets[basics.AssetIndex(crypto.RandUint64()%lastCreatableID)] = ah
}
diff --git a/libgoal/participation.go b/libgoal/participation.go
index c95d4c3c6..59999e031 100644
--- a/libgoal/participation.go
+++ b/libgoal/participation.go
@@ -165,6 +165,9 @@ func (c *Client) GenParticipationKeysTo(address string, firstValid, lastValid, k
// Fill the database with new participation keys
newPart, err := account.FillDBWithParticipationKeys(partdb, parsedAddr, firstRound, lastRound, keyDilution)
+ if err != nil {
+ return
+ }
part = newPart.Participation
newPart.Close()
return part, partKeyPath, err
diff --git a/libgoal/transactions.go b/libgoal/transactions.go
index d1c51a7e9..c0050c7d4 100644
--- a/libgoal/transactions.go
+++ b/libgoal/transactions.go
@@ -229,7 +229,7 @@ func (c *Client) MakeUnsignedGoOnlineTx(address string, part *account.Participat
parsedLastValid := basics.Round(lastValid)
parsedFee := basics.MicroAlgos{Raw: fee}
- goOnlineTransaction := part.GenerateRegistrationTransaction(parsedFee, parsedFrstValid, parsedLastValid, leaseBytes)
+ goOnlineTransaction := part.GenerateRegistrationTransaction(parsedFee, parsedFrstValid, parsedLastValid, leaseBytes, cparams)
if cparams.SupportGenesisHash {
var genHash crypto.Digest
copy(genHash[:], params.GenesisHash)
diff --git a/protocol/hash.go b/protocol/hash.go
index 846b03c27..404614993 100644
--- a/protocol/hash.go
+++ b/protocol/hash.go
@@ -38,6 +38,7 @@ const (
BlockHeader HashID = "BH"
BalanceRecord HashID = "BR"
Credential HashID = "CR"
+ EphemeralPK HashID = "EP"
Genesis HashID = "GE"
MerkleArrayNode HashID = "MA"
Message HashID = "MX"
@@ -56,5 +57,6 @@ const (
TxGroup HashID = "TG"
TxnMerkleLeaf HashID = "TL"
Transaction HashID = "TX"
+ VerifyingKey HashID = "VK"
Vote HashID = "VO"
)
diff --git a/test/e2e-go/features/compactcert/compactcert_test.go b/test/e2e-go/features/compactcert/compactcert_test.go
index b56897e08..4366f4bcf 100644
--- a/test/e2e-go/features/compactcert/compactcert_test.go
+++ b/test/e2e-go/features/compactcert/compactcert_test.go
@@ -24,7 +24,6 @@ import (
"github.com/stretchr/testify/require"
"github.com/algorand/go-algorand/config"
- "github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/crypto/compactcert"
"github.com/algorand/go-algorand/daemon/algod/api/spec/v1"
"github.com/algorand/go-algorand/data/basics"
@@ -135,7 +134,7 @@ func TestCompactCerts(t *testing.T) {
err = protocol.Decode(nextCertBlockRaw, &nextCertBlockDecoded)
r.NoError(err)
- var votersRoot crypto.Digest
+ var votersRoot = make([]byte, compactcert.HashSize)
copy(votersRoot[:], lastCertBlock.CompactCertVoters)
provenWeight, overflowed := basics.Muldiv(lastCertBlock.CompactCertVotersTotal, uint64(consensusParams.CompactCertWeightThreshold), 1<<32)
diff --git a/test/e2e-go/features/participation/overlappingParticipationKeys_test.go b/test/e2e-go/features/participation/overlappingParticipationKeys_test.go
index c98cf7a9e..62ed515a6 100644
--- a/test/e2e-go/features/participation/overlappingParticipationKeys_test.go
+++ b/test/e2e-go/features/participation/overlappingParticipationKeys_test.go
@@ -93,7 +93,7 @@ func TestOverlappingParticipationKeys(t *testing.T) {
txEndRound := txStartRound + 10 + 4
regStartRound := round
regEndRound := regStartRound + 11 + 4
- err = prepareParticipationKey(a, &fixture, acctIdx, txStartRound, txEndRound, regStartRound, regEndRound, genesisHash, rootKeys, regTransactions)
+ err = prepareParticipationKey(a, &fixture, acctIdx, txStartRound, txEndRound, regStartRound, regEndRound, genesisHash, rootKeys, regTransactions, config.Consensus[protocol.ConsensusCurrentVersion])
a.NoError(err)
}
@@ -110,6 +110,7 @@ func TestOverlappingParticipationKeys(t *testing.T) {
endRound := startRound + 10 + 4 - 2
regStartRound := currentRound
regEndRound := regStartRound + 11 + 4
+
pk, err := addParticipationKey(a, &fixture, acctIdx, startRound, endRound, regTransactions)
a.NoError(err)
t.Logf("[.] Round %d, Added reg key for node %d range [%d..%d] %s\n", currentRound, acctIdx, regStartRound, regEndRound, hex.EncodeToString(pk[:8]))
@@ -142,7 +143,7 @@ func addParticipationKey(a *require.Assertions, fixture *fixtures.RestClientFixt
return signedTxn.Txn.KeyregTxnFields.VotePK, err
}
-func prepareParticipationKey(a *require.Assertions, fixture *fixtures.RestClientFixture, acctNum uint64, txStartRound, txEndRound, regStartRound, regEndRound uint64, genesisHash crypto.Digest, rootKeys map[int]*account.Root, regTransactions map[int]transactions.SignedTxn) error {
+func prepareParticipationKey(a *require.Assertions, fixture *fixtures.RestClientFixture, acctNum, txStartRound, txEndRound, regStartRound, regEndRound uint64, genesisHash crypto.Digest, rootKeys map[int]*account.Root, regTransactions map[int]transactions.SignedTxn, c config.ConsensusParams) error {
dataDir := fixture.NodeDataDirs()[acctNum]
nc := fixture.GetNodeControllerForDataDir(dataDir)
@@ -204,7 +205,7 @@ func prepareParticipationKey(a *require.Assertions, fixture *fixtures.RestClient
partkeyHandle.Vacuum(context.Background())
persistedParticipation.Close()
- unsignedTxn := persistedParticipation.GenerateRegistrationTransaction(basics.MicroAlgos{Raw: 1000}, basics.Round(txStartRound), basics.Round(txEndRound), [32]byte{})
+ unsignedTxn := persistedParticipation.GenerateRegistrationTransaction(basics.MicroAlgos{Raw: 1000}, basics.Round(txStartRound), basics.Round(txEndRound), [32]byte{}, c)
copy(unsignedTxn.GenesisHash[:], genesisHash[:])
if err != nil {
a.NoError(err)
diff --git a/test/e2e-go/features/transactions/proof_test.go b/test/e2e-go/features/transactions/proof_test.go
index 2ef4b8e48..64acf4290 100644
--- a/test/e2e-go/features/transactions/proof_test.go
+++ b/test/e2e-go/features/transactions/proof_test.go
@@ -20,15 +20,31 @@ import (
"path/filepath"
"testing"
- "github.com/stretchr/testify/require"
-
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/crypto/merklearray"
"github.com/algorand/go-algorand/protocol"
"github.com/algorand/go-algorand/test/framework/fixtures"
"github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/stretchr/testify/require"
)
+// TxnMerkleElemRaw this struct helps creates a hashable struct from the bytes
+type TxnMerkleElemRaw struct {
+ Txn []byte // txn id
+ Stib []byte // hash value of transactions.SignedTxnInBlock
+}
+
+func txnMerkleToRaw(txid []byte, stib []byte) []byte {
+ buf := make([]byte, 0, 2*crypto.DigestSize)
+ buf = append(buf, txid...)
+ return append(buf, stib...)
+}
+
+// ToBeHashed implements the crypto.Hashable interface.
+func (tme *TxnMerkleElemRaw) ToBeHashed() (protocol.HashID, []byte) {
+ return protocol.TxnMerkleLeaf, txnMerkleToRaw(tme.Txn, tme.Stib)
+}
+
func TestTxnMerkleProof(t *testing.T) {
partitiontest.PartitionTest(t)
defer fixtures.ShutdownSynchronizedTest(t)
@@ -86,24 +102,24 @@ func TestTxnMerkleProof(t *testing.T) {
proofresp, err := client.TxnProof(txid.String(), confirmedTx.ConfirmedRound)
a.NoError(err)
- var proof []crypto.Digest
+ var proof merklearray.Proof
+ proof.HashFactory = crypto.HashFactory{HashType: crypto.Sha512_256}
proofconcat := []byte(proofresp.Proof)
for len(proofconcat) > 0 {
var d crypto.Digest
copy(d[:], proofconcat)
- proof = append(proof, d)
+ proof.Path = append(proof.Path, d[:])
proofconcat = proofconcat[len(d):]
}
blk, err := client.BookkeepingBlock(confirmedTx.ConfirmedRound)
a.NoError(err)
- merkleNode := []byte(protocol.TxnMerkleLeaf)
- merkleNode = append(merkleNode, txid[:]...)
- merkleNode = append(merkleNode, proofresp.Stibhash...)
+ element := TxnMerkleElemRaw{Txn: txid[:], Stib: proofresp.Stibhash}
+
+ elems := make(map[uint64]crypto.Hashable)
- elems := make(map[uint64]crypto.Digest)
- elems[proofresp.Idx] = crypto.Hash(merkleNode)
- err = merklearray.Verify(blk.TxnRoot, elems, proof)
+ elems[proofresp.Idx] = &element
+ err = merklearray.Verify(blk.TxnRoot.ToSlice(), elems, &proof)
a.NoError(err)
}
diff --git a/test/e2e-go/upgrades/send_receive_upgrade_test.go b/test/e2e-go/upgrades/send_receive_upgrade_test.go
index b67a5b21d..0dbb2174b 100644
--- a/test/e2e-go/upgrades/send_receive_upgrade_test.go
+++ b/test/e2e-go/upgrades/send_receive_upgrade_test.go
@@ -122,14 +122,26 @@ func testAccountsCanSendMoneyAcrossUpgrade(t *testing.T, templatePath string) {
fixture.SetConsensus(consensus)
fixture.Setup(t, templatePath)
defer fixture.Shutdown()
- c := fixture.LibGoalClient
+ verifyAccountsCanSendMoneyAcrossUpgrade(a, &fixture)
+}
+
+func verifyAccountsCanSendMoneyAcrossUpgrade(a *require.Assertions, fixture *fixtures.RestClientFixture) {
+ pingBalance, pongBalance, expectedPingBalance, expectedPongBalance := runUntilProtocolUpgrades(a, fixture)
+
+ a.True(expectedPingBalance <= pingBalance, "ping balance is different than expected")
+ a.True(expectedPongBalance <= pongBalance, "pong balance is different than expected")
+}
+
+func runUntilProtocolUpgrades(a *require.Assertions, fixture *fixtures.RestClientFixture) (uint64, uint64, uint64, uint64) {
+ c := fixture.LibGoalClient
initialStatus, err := c.Status()
a.NoError(err, "getting status")
pingClient := fixture.LibGoalClient
pingAccountList, err := fixture.GetWalletsSortedByBalance()
a.NoError(err, "fixture should be able to get wallets sorted by balance")
+ a.NotEmpty(pingAccountList)
pingAccount := pingAccountList[0].Address
pongClient := fixture.GetLibGoalClientForNamedNode("Node")
@@ -256,7 +268,5 @@ func testAccountsCanSendMoneyAcrossUpgrade(t *testing.T, templatePath string) {
a.NoError(err)
pongBalance, err = c.GetBalance(pongAccount)
a.NoError(err)
-
- a.True(expectedPingBalance <= pingBalance, "ping balance is different than expected")
- a.True(expectedPongBalance <= pongBalance, "pong balance is different than expected")
+ return pingBalance, pongBalance, expectedPingBalance, expectedPongBalance
}
diff --git a/test/e2e-go/upgrades/stateproof_test.go b/test/e2e-go/upgrades/stateproof_test.go
new file mode 100644
index 000000000..01d1c28e9
--- /dev/null
+++ b/test/e2e-go/upgrades/stateproof_test.go
@@ -0,0 +1,160 @@
+// Copyright (C) 2019-2021 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see <https://www.gnu.org/licenses/>.
+
+package upgrades
+
+import (
+ "path/filepath"
+ "testing"
+
+ "github.com/algorand/go-algorand/config"
+ "github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/data/basics"
+ "github.com/algorand/go-algorand/protocol"
+ "github.com/algorand/go-algorand/test/framework/fixtures"
+ "github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/stretchr/testify/require"
+)
+
+func TestKeysWithoutStateProofKeyCannotRegister(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ defer fixtures.ShutdownSynchronizedTest(t)
+
+ a := require.New(fixtures.SynchronizedTest(t))
+ consensus := getStateProofConcensus()
+
+ var fixture fixtures.RestClientFixture
+ fixture.SetConsensus(consensus)
+ fixture.Setup(t, filepath.Join("nettemplates", "TwoNodesWithoutStateProofPartkeys.json"))
+ defer fixture.Shutdown()
+ lastValid := uint64(1000 * 5)
+
+ a.NoError(registerKey(&fixture, a, lastValid, protocol.ConsensusV29))
+ a.Error(registerKey(&fixture, a, lastValid+1, protocol.ConsensusFuture))
+
+ runUntilProtocolUpgrades(a, &fixture)
+
+ a.Error(registerKey(&fixture, a, lastValid+2, protocol.ConsensusV29))
+ a.NoError(registerKey(&fixture, a, lastValid+3, protocol.ConsensusFuture))
+}
+
+func registerKey(fixture *fixtures.RestClientFixture, a *require.Assertions, lastValid uint64, ver protocol.ConsensusVersion) error {
+ _, err := registerKeyInto("Node", fixture, a, lastValid, ver)
+ return err
+}
+
+func registerKeyInto(nodeName string, fixture *fixtures.RestClientFixture, a *require.Assertions, lastValid uint64, ver protocol.ConsensusVersion) (string, error) {
+ client := fixture.GetLibGoalClientForNamedNode(nodeName)
+ wh, err := client.GetUnencryptedWalletHandle()
+ a.NoError(err)
+ actList, err := client.ListAddresses(wh)
+ a.NoError(err)
+ addr := actList[0]
+
+ pongBalance, err := client.GetBalance(addr)
+ a.NoError(err)
+ a.Greater(pongBalance, uint64(10000))
+
+ partKey, _, err := client.GenParticipationKeys(addr, 1, lastValid, 1000)
+ a.NoError(err)
+
+ cparams := config.Consensus[ver]
+
+ tx := partKey.GenerateRegistrationTransaction(
+ basics.MicroAlgos{Raw: 1000},
+ 0,
+ 100,
+ [32]byte{},
+ cparams,
+ )
+
+ if cparams.SupportGenesisHash {
+ prms, err := client.SuggestedParams()
+ a.NoError(err)
+
+ var genHash crypto.Digest
+ copy(genHash[:], prms.GenesisHash)
+ tx.GenesisHash = genHash
+ }
+
+ return client.SignAndBroadcastTransaction(wh, nil, tx)
+}
+
+func getStateProofConcensus() config.ConsensusProtocols {
+ consensus := generateFastUpgradeConsensus()
+
+ // TODO: when upgrading from v29, need to change this from future to v30.
+ consensus[consensusTestFastUpgrade(protocol.ConsensusV29)].
+ ApprovedUpgrades[consensusTestFastUpgrade(protocol.ConsensusFuture)] = 0
+ return consensus
+}
+
+//TODO: copied code from other test: onlineOfflineParticipation_test.go.
+// consider how to avoid duplication
+func waitForAccountToProposeBlock(a *require.Assertions, fixture *fixtures.RestClientFixture, account string, window int) bool {
+ client := fixture.AlgodClient
+
+ curStatus, err := client.Status()
+ a.NoError(err)
+ curRound := curStatus.LastRound
+
+ // the below window controls the likelihood a block will be proposed by the account under test
+ // since block proposer selection is probabilistic, it is not guaranteed that the account will be chosen
+ // it is a trade-off between test flakiness and test duration
+ for window > 0 {
+ window--
+ curRound++
+ err := fixture.WaitForRoundWithTimeout(curRound)
+ a.NoErrorf(err, "fixture failed waiting for round %d", curRound)
+
+ // See if account was participating by looking at block proposers
+ blockWasProposed := fixture.VerifyBlockProposed(account, 1)
+ if blockWasProposed {
+ return blockWasProposed
+ }
+ }
+ return false
+}
+
+// This test starts with participation keys in Version29, then attempts to let the richest user participate even after
+// consensus upgrade.
+func TestParticipationWithoutStateProofKeys(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ defer fixtures.ShutdownSynchronizedTest(t)
+
+ a := require.New(fixtures.SynchronizedTest(t))
+
+ consensus := getStateProofConcensus()
+
+ var fixture fixtures.RestClientFixture
+ fixture.SetConsensus(consensus)
+ fixture.Setup(t, filepath.Join("nettemplates", "TwoNodesWithoutStateProofPartkeys.json"))
+ defer fixture.Shutdown()
+ // Want someone to start with a key to participate with...
+
+ act, err := fixture.GetRichestAccount()
+ a.NoError(err)
+
+ var address = act.Address
+
+ runUntilProtocolUpgrades(a, &fixture)
+
+ a.NotEmpty(address)
+
+ proposalWindow := 50 // giving 50 rounds to participate, should be able to participate every second round.
+ blockWasProposedByPartkeyOnlyAccountRecently := waitForAccountToProposeBlock(a, &fixture, address, proposalWindow)
+ a.True(blockWasProposedByPartkeyOnlyAccountRecently, "partkey-only account should be proposing blocks")
+}
diff --git a/test/testdata/nettemplates/TwoNodesWithoutStateProofPartkeys.json b/test/testdata/nettemplates/TwoNodesWithoutStateProofPartkeys.json
new file mode 100644
index 000000000..c6c2ae0e9
--- /dev/null
+++ b/test/testdata/nettemplates/TwoNodesWithoutStateProofPartkeys.json
@@ -0,0 +1,40 @@
+{
+ "Genesis": {
+ "NetworkName": "tbd",
+
+ "ConsensusProtocol": "test-fast-upgrade-https://github.com/algorandfoundation/specs/tree/abc54f79f9ad679d2d22f0fb9909fb005c16f8a1",
+ "Wallets": [
+ {
+ "Name": "Wallet1",
+ "Stake": 50,
+ "Online": true
+ },
+ {
+ "Name": "Wallet2",
+ "Stake": 50,
+ "Online": true
+ }
+ ]
+ },
+ "Nodes": [
+ {
+ "Name": "Primary",
+ "IsRelay": true,
+ "Wallets": [
+ {
+ "Name": "Wallet1",
+ "ParticipationOnly": false
+ }
+ ]
+ },
+ {
+ "Name": "Node",
+ "Wallets": [
+ {
+ "Name": "Wallet2",
+ "ParticipationOnly": false
+ }
+ ]
+ }
+ ]
+}
diff --git a/test/testdata/nettemplates/UpgradeIntoCompactCert.json b/test/testdata/nettemplates/UpgradeIntoCompactCert.json
new file mode 100644
index 000000000..15b163078
--- /dev/null
+++ b/test/testdata/nettemplates/UpgradeIntoCompactCert.json
@@ -0,0 +1,41 @@
+{
+ "Genesis": {
+ "NetworkName": "tbd",
+ "ConsensusProtocol": "test-fast-upgrade-https://github.com/algorandfoundation/specs/tree/abc54f79f9ad679d2d22f0fb9909fb005c16f8a1",
+ "Wallets": [
+ {
+ "Name": "Wallet1",
+ "Stake": 50,
+ "Online": true
+ },
+ {
+ "Name": "Wallet2",
+ "Stake": 50,
+ "Online": true
+ }
+ ]
+ },
+ "Nodes": [
+ {
+ "Name": "Primary",
+ "IsRelay": true,
+ "Wallets": [
+ {
+ "Name": "Wallet1",
+ "IsRelay": true,
+ "ParticipationOnly": false
+ }
+ ]
+ },
+ {
+ "Name": "Node",
+ "Wallets": [
+ {
+ "Name": "Wallet2",
+ "IsRelay": true,
+ "ParticipationOnly": false
+ }
+ ]
+ }
+ ]
+}
diff --git a/txnsync/encodedgroupsmarshalers.go b/txnsync/encodedgroupsmarshalers.go
index 583f9ede1..97253d95e 100644
--- a/txnsync/encodedgroupsmarshalers.go
+++ b/txnsync/encodedgroupsmarshalers.go
@@ -18,8 +18,8 @@ package txnsync
import (
"fmt"
-
"github.com/algorand/go-algorand/crypto"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/transactions"
"github.com/algorand/go-algorand/protocol"
@@ -313,11 +313,15 @@ func (stub *txGroupsEncodingStub) deconstructKeyregTxnFields(i int, txn *transac
stub.VotePK = make([]byte, 0, stub.TotalTransactionsCount*crypto.PublicKeyByteLength)
stub.SelectionPK = make([]byte, 0, stub.TotalTransactionsCount*crypto.VrfPubkeyByteLength)
stub.VoteKeyDilution = make([]uint64, 0, stub.TotalTransactionsCount)
+ stub.HasValidRoot = make([]bool, 0, stub.TotalTransactionsCount)
+ stub.CommitmentRoot = make([]byte, 0, stub.TotalTransactionsCount*merklekeystore.KeyStoreRootSize)
}
stub.BitmaskKeys.setBit(i)
stub.VotePK = append(stub.VotePK, txn.Txn.VotePK[:]...)
stub.SelectionPK = append(stub.SelectionPK, txn.Txn.SelectionPK[:]...)
stub.VoteKeyDilution = append(stub.VoteKeyDilution, txn.Txn.VoteKeyDilution)
+ stub.HasValidRoot = append(stub.HasValidRoot, txn.Txn.BlockProofPK.HasValidRoot)
+ stub.CommitmentRoot = append(stub.CommitmentRoot, txn.Txn.BlockProofPK.Root[:]...)
}
if !txn.Txn.VoteFirst.MsgIsZero() {
if len(stub.BitmaskVoteFirst) == 0 {
@@ -744,14 +748,15 @@ func (stub *txGroupsEncodingStub) finishDeconstructCompactCertTxnFields() {
func (stub *txGroupsEncodingStub) deconstructCert(i int, txn *transactions.SignedTxn) {
bitmaskLen := bytesNeededBitmask(int(stub.TotalTransactionsCount))
- if !txn.Txn.Cert.SigCommit.MsgIsZero() {
+ if txn.Txn.Cert.SigCommit != nil {
if len(stub.BitmaskSigCommit) == 0 {
stub.BitmaskSigCommit = make(bitmask, bitmaskLen)
- stub.SigCommit = make([]byte, 0, stub.TotalTransactionsCount*crypto.DigestSize)
+ stub.SigCommit = make([]crypto.GenericDigest, 0, stub.TotalTransactionsCount)
}
stub.BitmaskSigCommit.setBit(i)
- stub.SigCommit = append(stub.SigCommit, txn.Txn.Cert.SigCommit[:]...)
+ stub.SigCommit = append(stub.SigCommit, txn.Txn.Cert.SigCommit)
}
+
if txn.Txn.Cert.SignedWeight != 0 {
if len(stub.BitmaskSignedWeight) == 0 {
stub.BitmaskSignedWeight = make(bitmask, bitmaskLen)
@@ -760,22 +765,43 @@ func (stub *txGroupsEncodingStub) deconstructCert(i int, txn *transactions.Signe
stub.BitmaskSignedWeight.setBit(i)
stub.SignedWeight = append(stub.SignedWeight, txn.Txn.Cert.SignedWeight)
}
- if txn.Txn.Cert.SigProofs != nil {
+ if txn.Txn.Cert.SigProofs.Path != nil {
if len(stub.BitmaskSigProofs) == 0 {
stub.BitmaskSigProofs = make(bitmask, bitmaskLen)
stub.SigProofs = make([]certProofs, 0, stub.TotalTransactionsCount)
}
stub.BitmaskSigProofs.setBit(i)
- stub.SigProofs = append(stub.SigProofs, txn.Txn.Cert.SigProofs)
+ stub.SigProofs = append(stub.SigProofs, txn.Txn.Cert.SigProofs.Path)
+ }
+
+ if txn.Txn.Cert.SigProofs.HashFactory.HashType != 0 {
+ if len(stub.BitmaskSigsHash) == 0 {
+ stub.BitmaskSigsHash = make(bitmask, bitmaskLen)
+ stub.SigProofHashTypes = make([]uint64, 0, stub.TotalTransactionsCount)
+ }
+ stub.BitmaskSigsHash.setBit(i)
+ stub.SigProofHashTypes = append(stub.SigProofHashTypes, uint64(txn.Txn.Cert.SigProofs.HashFactory.HashType))
}
- if txn.Txn.Cert.PartProofs != nil {
+
+ if txn.Txn.Cert.PartProofs.Path != nil {
if len(stub.BitmaskPartProofs) == 0 {
stub.BitmaskPartProofs = make(bitmask, bitmaskLen)
stub.PartProofs = make([]certProofs, 0, stub.TotalTransactionsCount)
+
}
stub.BitmaskPartProofs.setBit(i)
- stub.PartProofs = append(stub.PartProofs, txn.Txn.Cert.PartProofs)
+ stub.PartProofs = append(stub.PartProofs, txn.Txn.Cert.PartProofs.Path)
}
+
+ if txn.Txn.Cert.PartProofs.HashFactory.HashType != 0 {
+ if len(stub.BitmaskPartHash) == 0 {
+ stub.BitmaskPartHash = make(bitmask, bitmaskLen)
+ stub.PartProofHashTypes = make([]uint64, 0, stub.TotalTransactionsCount)
+ }
+ stub.BitmaskPartHash.setBit(i)
+ stub.PartProofHashTypes = append(stub.PartProofHashTypes, uint64(txn.Txn.Cert.PartProofs.HashFactory.HashType))
+ }
+
if txn.Txn.Cert.Reveals != nil {
if len(stub.BitmaskReveals) == 0 {
stub.BitmaskReveals = make(bitmask, bitmaskLen)
diff --git a/txnsync/encodedgroupstypes.go b/txnsync/encodedgroupstypes.go
index 727d67ee8..51d77fa03 100644
--- a/txnsync/encodedgroupstypes.go
+++ b/txnsync/encodedgroupstypes.go
@@ -18,12 +18,12 @@ package txnsync
import (
"errors"
+ "github.com/algorand/go-algorand/crypto/compactcert"
+ "github.com/algorand/go-algorand/protocol"
"github.com/algorand/go-algorand/crypto"
- "github.com/algorand/go-algorand/crypto/compactcert"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/pooldata"
- "github.com/algorand/go-algorand/protocol"
)
const maxEncodedTransactionGroups = 30000
@@ -143,6 +143,8 @@ type encodedKeyregTxnFields struct {
VoteKeyDilution []uint64 `codec:"votekd,allocbound=maxEncodedTransactionGroups"`
BitmaskKeys bitmask `codec:"votekbm"`
BitmaskNonparticipation bitmask `codec:"nonpartbm"`
+ HasValidRoot []bool `codec:"vldrt,allocbound=maxEncodedTransactionGroups"`
+ CommitmentRoot []byte `codec:"comt,allocbound=maxEncodedTransactionGroups"`
}
type encodedPaymentTxnFields struct {
@@ -302,7 +304,7 @@ type encodedCompactCertTxnFields struct {
}
//msgp:allocbound certProofs compactcert.MaxProofDigests
-type certProofs []crypto.Digest
+type certProofs []crypto.GenericDigest
//msgp:allocbound revealMap compactcert.MaxReveals
type revealMap map[uint64]compactcert.Reveal
@@ -314,8 +316,8 @@ type SortUint64 = compactcert.SortUint64
type encodedCert struct {
_struct struct{} `codec:",omitempty,omitemptyarray"` //nolint:structcheck,unused
- SigCommit []byte `codec:"certc,allocbound=maxAddressBytes"`
- BitmaskSigCommit bitmask `codec:"certcbm"`
+ SigCommit []crypto.GenericDigest `codec:"certc,allocbound=maxAddressBytes"`
+ BitmaskSigCommit bitmask `codec:"certcbm"`
SignedWeight []uint64 `codec:"certw,allocbound=maxEncodedTransactionGroups"`
BitmaskSignedWeight bitmask `codec:"certwbm"`
@@ -323,9 +325,15 @@ type encodedCert struct {
SigProofs []certProofs `codec:"certS,allocbound=maxEncodedTransactionGroups"`
BitmaskSigProofs bitmask `codec:"certSbm"`
+ SigProofHashTypes []uint64 `codec:"certSH,allocbound=maxEncodedTransactionGroups"`
+ BitmaskSigsHash bitmask `codec:"certSHbm"`
+
PartProofs []certProofs `codec:"certP,allocbound=maxEncodedTransactionGroups"`
BitmaskPartProofs bitmask `codec:"certPbm"`
+ PartProofHashTypes []uint64 `codec:"certPH,allocbound=maxEncodedTransactionGroups"`
+ BitmaskPartHash bitmask `codec:"certPHbm"`
+
Reveals []revealMap `codec:"certr,allocbound=maxEncodedTransactionGroups"`
BitmaskReveals bitmask `codec:"certrbm"`
}
diff --git a/txnsync/encodedgroupsunmarshalers.go b/txnsync/encodedgroupsunmarshalers.go
index 750bb0871..89f228f78 100644
--- a/txnsync/encodedgroupsunmarshalers.go
+++ b/txnsync/encodedgroupsunmarshalers.go
@@ -19,6 +19,7 @@ package txnsync
import (
"errors"
"fmt"
+ "github.com/algorand/go-algorand/crypto/merklekeystore"
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
@@ -276,16 +277,24 @@ func (stub *txGroupsEncodingStub) reconstructTxnHeader(signedTxns []transactions
func (stub *txGroupsEncodingStub) reconstructKeyregTxnFields(signedTxns []transactions.SignedTxn) (err error) {
// should all have same number of elements
- if len(stub.VotePK)/len(crypto.OneTimeSignatureVerifier{}) != len(stub.VoteKeyDilution) || len(stub.SelectionPK)/len(crypto.VRFVerifier{}) != len(stub.VoteKeyDilution) {
+ if len(stub.VotePK)/len(crypto.OneTimeSignatureVerifier{}) != len(stub.VoteKeyDilution) ||
+ len(stub.SelectionPK)/len(crypto.VRFVerifier{}) != len(stub.VoteKeyDilution) ||
+ len(stub.CommitmentRoot)/merklekeystore.KeyStoreRootSize != len(stub.VoteKeyDilution) {
return errDataMissing
}
err = stub.BitmaskKeys.iterate(int(stub.TotalTransactionsCount), len(stub.VoteKeyDilution), func(i int, index int) error {
signedTxns[i].Txn.VoteKeyDilution = stub.VoteKeyDilution[index]
+ signedTxns[i].Txn.BlockProofPK.HasValidRoot = stub.HasValidRoot[index]
+
err := nextSlice(&stub.VotePK, signedTxns[i].Txn.VotePK[:], len(crypto.OneTimeSignatureVerifier{}))
if err != nil {
return err
}
- return nextSlice(&stub.SelectionPK, signedTxns[i].Txn.SelectionPK[:], len(crypto.VRFVerifier{}))
+ err = nextSlice(&stub.SelectionPK, signedTxns[i].Txn.SelectionPK[:], len(crypto.VRFVerifier{}))
+ if err != nil {
+ return err
+ }
+ return nextSlice(&stub.CommitmentRoot, signedTxns[i].Txn.BlockProofPK.Root[:], merklekeystore.KeyStoreRootSize)
})
if err != nil {
return err
@@ -318,6 +327,7 @@ func (stub *txGroupsEncodingStub) reconstructKeyregTxnFields(signedTxns []transa
if err != nil {
return err
}
+
return nil
}
@@ -610,8 +620,9 @@ func (stub *txGroupsEncodingStub) reconstructCompactCertTxnFields(signedTxns []t
}
func (stub *txGroupsEncodingStub) reconstructCert(signedTxns []transactions.SignedTxn) (err error) {
- err = stub.BitmaskSigCommit.iterate(int(stub.TotalTransactionsCount), len(stub.SigCommit)/crypto.DigestSize, func(i int, index int) error {
- return nextSlice(&stub.SigCommit, signedTxns[i].Txn.Cert.SigCommit[:], crypto.DigestSize)
+ err = stub.BitmaskSigCommit.iterate(int(stub.TotalTransactionsCount), len(stub.SigCommit), func(i int, index int) error {
+ signedTxns[i].Txn.Cert.SigCommit = stub.SigCommit[index]
+ return nil
})
if err != nil {
return err
@@ -620,20 +631,31 @@ func (stub *txGroupsEncodingStub) reconstructCert(signedTxns []transactions.Sign
signedTxns[i].Txn.Cert.SignedWeight = stub.SignedWeight[index]
return nil
})
+
if err != nil {
return err
}
err = stub.BitmaskSigProofs.iterate(int(stub.TotalTransactionsCount), len(stub.SigProofs), func(i int, index int) error {
- signedTxns[i].Txn.Cert.SigProofs = stub.SigProofs[index]
+ signedTxns[i].Txn.Cert.SigProofs.Path = stub.SigProofs[index]
return nil
})
+ err = stub.BitmaskSigsHash.iterate(int(stub.TotalTransactionsCount), len(stub.SigProofHashTypes), func(i int, index int) error {
+ signedTxns[i].Txn.Cert.SigProofs.HashFactory.HashType = crypto.HashType(stub.SigProofHashTypes[index])
+ return nil
+ })
+
if err != nil {
return err
}
err = stub.BitmaskPartProofs.iterate(int(stub.TotalTransactionsCount), len(stub.PartProofs), func(i int, index int) error {
- signedTxns[i].Txn.Cert.PartProofs = stub.PartProofs[index]
+ signedTxns[i].Txn.Cert.PartProofs.Path = stub.PartProofs[index]
return nil
})
+ err = stub.BitmaskPartHash.iterate(int(stub.TotalTransactionsCount), len(stub.PartProofHashTypes), func(i int, index int) error {
+ signedTxns[i].Txn.Cert.PartProofs.HashFactory.HashType = crypto.HashType(stub.PartProofHashTypes[index])
+ return nil
+ })
+
if err != nil {
return err
}
diff --git a/txnsync/msgp_gen.go b/txnsync/msgp_gen.go
index 1c1b51256..9e9c94693 100644
--- a/txnsync/msgp_gen.go
+++ b/txnsync/msgp_gen.go
@@ -6539,52 +6539,68 @@ func (z *encodedBloomFilter) MsgIsZero() bool {
func (z *encodedCert) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0009Len := uint32(10)
- var zb0009Mask uint16 /* 11 bits */
+ zb0012Len := uint32(14)
+ var zb0012Mask uint16 /* 15 bits */
if len((*z).PartProofs) == 0 {
- zb0009Len--
- zb0009Mask |= 0x2
+ zb0012Len--
+ zb0012Mask |= 0x2
+ }
+ if len((*z).PartProofHashTypes) == 0 {
+ zb0012Len--
+ zb0012Mask |= 0x4
+ }
+ if len((*z).BitmaskPartHash) == 0 {
+ zb0012Len--
+ zb0012Mask |= 0x8
}
if len((*z).BitmaskPartProofs) == 0 {
- zb0009Len--
- zb0009Mask |= 0x4
+ zb0012Len--
+ zb0012Mask |= 0x10
}
if len((*z).SigProofs) == 0 {
- zb0009Len--
- zb0009Mask |= 0x8
+ zb0012Len--
+ zb0012Mask |= 0x20
+ }
+ if len((*z).SigProofHashTypes) == 0 {
+ zb0012Len--
+ zb0012Mask |= 0x40
+ }
+ if len((*z).BitmaskSigsHash) == 0 {
+ zb0012Len--
+ zb0012Mask |= 0x80
}
if len((*z).BitmaskSigProofs) == 0 {
- zb0009Len--
- zb0009Mask |= 0x10
+ zb0012Len--
+ zb0012Mask |= 0x100
}
if len((*z).SigCommit) == 0 {
- zb0009Len--
- zb0009Mask |= 0x20
+ zb0012Len--
+ zb0012Mask |= 0x200
}
if len((*z).BitmaskSigCommit) == 0 {
- zb0009Len--
- zb0009Mask |= 0x40
+ zb0012Len--
+ zb0012Mask |= 0x400
}
if len((*z).Reveals) == 0 {
- zb0009Len--
- zb0009Mask |= 0x80
+ zb0012Len--
+ zb0012Mask |= 0x800
}
if len((*z).BitmaskReveals) == 0 {
- zb0009Len--
- zb0009Mask |= 0x100
+ zb0012Len--
+ zb0012Mask |= 0x1000
}
if len((*z).SignedWeight) == 0 {
- zb0009Len--
- zb0009Mask |= 0x200
+ zb0012Len--
+ zb0012Mask |= 0x2000
}
if len((*z).BitmaskSignedWeight) == 0 {
- zb0009Len--
- zb0009Mask |= 0x400
+ zb0012Len--
+ zb0012Mask |= 0x4000
}
- // variable map header, size zb0009Len
- o = append(o, 0x80|uint8(zb0009Len))
- if zb0009Len != 0 {
- if (zb0009Mask & 0x2) == 0 { // if not empty
+ // variable map header, size zb0012Len
+ o = append(o, 0x80|uint8(zb0012Len))
+ if zb0012Len != 0 {
+ if (zb0012Mask & 0x2) == 0 { // if not empty
// string "certP"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x50)
if (*z).PartProofs == nil {
@@ -6592,23 +6608,40 @@ func (z *encodedCert) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).PartProofs)))
}
- for zb0004 := range (*z).PartProofs {
- if (*z).PartProofs[zb0004] == nil {
+ for zb0006 := range (*z).PartProofs {
+ if (*z).PartProofs[zb0006] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).PartProofs[zb0004])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).PartProofs[zb0006])))
}
- for zb0005 := range (*z).PartProofs[zb0004] {
- o = (*z).PartProofs[zb0004][zb0005].MarshalMsg(o)
+ for zb0007 := range (*z).PartProofs[zb0006] {
+ o = (*z).PartProofs[zb0006][zb0007].MarshalMsg(o)
}
}
}
- if (zb0009Mask & 0x4) == 0 { // if not empty
+ if (zb0012Mask & 0x4) == 0 { // if not empty
+ // string "certPH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48)
+ if (*z).PartProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).PartProofHashTypes)))
+ }
+ for zb0008 := range (*z).PartProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).PartProofHashTypes[zb0008])
+ }
+ }
+ if (zb0012Mask & 0x8) == 0 { // if not empty
+ // string "certPHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).BitmaskPartHash))
+ }
+ if (zb0012Mask & 0x10) == 0 { // if not empty
// string "certPbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x50, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskPartProofs))
}
- if (zb0009Mask & 0x8) == 0 { // if not empty
+ if (zb0012Mask & 0x20) == 0 { // if not empty
// string "certS"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x53)
if (*z).SigProofs == nil {
@@ -6616,33 +6649,57 @@ func (z *encodedCert) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).SigProofs)))
}
- for zb0002 := range (*z).SigProofs {
- if (*z).SigProofs[zb0002] == nil {
+ for zb0003 := range (*z).SigProofs {
+ if (*z).SigProofs[zb0003] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).SigProofs[zb0002])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).SigProofs[zb0003])))
}
- for zb0003 := range (*z).SigProofs[zb0002] {
- o = (*z).SigProofs[zb0002][zb0003].MarshalMsg(o)
+ for zb0004 := range (*z).SigProofs[zb0003] {
+ o = (*z).SigProofs[zb0003][zb0004].MarshalMsg(o)
}
}
}
- if (zb0009Mask & 0x10) == 0 { // if not empty
+ if (zb0012Mask & 0x40) == 0 { // if not empty
+ // string "certSH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48)
+ if (*z).SigProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).SigProofHashTypes)))
+ }
+ for zb0005 := range (*z).SigProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).SigProofHashTypes[zb0005])
+ }
+ }
+ if (zb0012Mask & 0x80) == 0 { // if not empty
+ // string "certSHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).BitmaskSigsHash))
+ }
+ if (zb0012Mask & 0x100) == 0 { // if not empty
// string "certSbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x53, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskSigProofs))
}
- if (zb0009Mask & 0x20) == 0 { // if not empty
+ if (zb0012Mask & 0x200) == 0 { // if not empty
// string "certc"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x63)
- o = msgp.AppendBytes(o, (*z).SigCommit)
+ if (*z).SigCommit == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).SigCommit)))
+ }
+ for zb0001 := range (*z).SigCommit {
+ o = (*z).SigCommit[zb0001].MarshalMsg(o)
+ }
}
- if (zb0009Mask & 0x40) == 0 { // if not empty
+ if (zb0012Mask & 0x400) == 0 { // if not empty
// string "certcbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskSigCommit))
}
- if (zb0009Mask & 0x80) == 0 { // if not empty
+ if (zb0012Mask & 0x800) == 0 { // if not empty
// string "certr"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x72)
if (*z).Reveals == nil {
@@ -6650,31 +6707,31 @@ func (z *encodedCert) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).Reveals)))
}
- for zb0006 := range (*z).Reveals {
- if (*z).Reveals[zb0006] == nil {
+ for zb0009 := range (*z).Reveals {
+ if (*z).Reveals[zb0009] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).Reveals[zb0006])))
+ o = msgp.AppendMapHeader(o, uint32(len((*z).Reveals[zb0009])))
}
- zb0007_keys := make([]uint64, 0, len((*z).Reveals[zb0006]))
- for zb0007 := range (*z).Reveals[zb0006] {
- zb0007_keys = append(zb0007_keys, zb0007)
+ zb0010_keys := make([]uint64, 0, len((*z).Reveals[zb0009]))
+ for zb0010 := range (*z).Reveals[zb0009] {
+ zb0010_keys = append(zb0010_keys, zb0010)
}
- sort.Sort(SortUint64(zb0007_keys))
- for _, zb0007 := range zb0007_keys {
- zb0008 := (*z).Reveals[zb0006][zb0007]
- _ = zb0008
- o = msgp.AppendUint64(o, zb0007)
- o = zb0008.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0010_keys))
+ for _, zb0010 := range zb0010_keys {
+ zb0011 := (*z).Reveals[zb0009][zb0010]
+ _ = zb0011
+ o = msgp.AppendUint64(o, zb0010)
+ o = zb0011.MarshalMsg(o)
}
}
}
- if (zb0009Mask & 0x100) == 0 { // if not empty
+ if (zb0012Mask & 0x1000) == 0 { // if not empty
// string "certrbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskReveals))
}
- if (zb0009Mask & 0x200) == 0 { // if not empty
+ if (zb0012Mask & 0x2000) == 0 { // if not empty
// string "certw"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x77)
if (*z).SignedWeight == nil {
@@ -6682,11 +6739,11 @@ func (z *encodedCert) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).SignedWeight)))
}
- for zb0001 := range (*z).SignedWeight {
- o = msgp.AppendUint64(o, (*z).SignedWeight[zb0001])
+ for zb0002 := range (*z).SignedWeight {
+ o = msgp.AppendUint64(o, (*z).SignedWeight[zb0002])
}
}
- if (zb0009Mask & 0x400) == 0 { // if not empty
+ if (zb0012Mask & 0x4000) == 0 { // if not empty
// string "certwbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x77, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskSignedWeight))
@@ -6704,331 +6761,444 @@ func (_ *encodedCert) CanMarshalMsg(z interface{}) bool {
func (z *encodedCert) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0009 int
- var zb0010 bool
- zb0009, zb0010, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0012 int
+ var zb0013 bool
+ zb0012, zb0013, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0009, zb0010, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0012, zb0013, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0009 > 0 {
- zb0009--
- var zb0011 int
- zb0011, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0012 > 0 {
+ zb0012--
+ var zb0014 int
+ var zb0015 bool
+ zb0014, zb0015, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
- if zb0011 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0011), uint64(maxAddressBytes))
- return
- }
- (*z).SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).SigCommit)
- if err != nil {
+ if zb0014 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0014), uint64(maxAddressBytes))
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
+ if zb0015 {
+ (*z).SigCommit = nil
+ } else if (*z).SigCommit != nil && cap((*z).SigCommit) >= zb0014 {
+ (*z).SigCommit = ((*z).SigCommit)[:zb0014]
+ } else {
+ (*z).SigCommit = make([]crypto.GenericDigest, zb0014)
+ }
+ for zb0001 := range (*z).SigCommit {
+ bts, err = (*z).SigCommit[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigCommit", zb0001)
+ return
+ }
+ }
}
- if zb0009 > 0 {
- zb0009--
+ if zb0012 > 0 {
+ zb0012--
{
- var zb0012 []byte
- var zb0013 int
- zb0013, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0016 []byte
+ var zb0017 int
+ zb0017, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- if zb0013 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0013), uint64(maxBitmaskSize))
+ if zb0017 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0017), uint64(maxBitmaskSize))
return
}
- zb0012, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigCommit))
+ zb0016, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- (*z).BitmaskSigCommit = bitmask(zb0012)
+ (*z).BitmaskSigCommit = bitmask(zb0016)
}
}
- if zb0009 > 0 {
- zb0009--
- var zb0014 int
- var zb0015 bool
- zb0014, zb0015, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0012 > 0 {
+ zb0012--
+ var zb0018 int
+ var zb0019 bool
+ zb0018, zb0019, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0014 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0014), uint64(maxEncodedTransactionGroups))
+ if zb0018 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0018), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0015 {
+ if zb0019 {
(*z).SignedWeight = nil
- } else if (*z).SignedWeight != nil && cap((*z).SignedWeight) >= zb0014 {
- (*z).SignedWeight = ((*z).SignedWeight)[:zb0014]
+ } else if (*z).SignedWeight != nil && cap((*z).SignedWeight) >= zb0018 {
+ (*z).SignedWeight = ((*z).SignedWeight)[:zb0018]
} else {
- (*z).SignedWeight = make([]uint64, zb0014)
+ (*z).SignedWeight = make([]uint64, zb0018)
}
- for zb0001 := range (*z).SignedWeight {
- (*z).SignedWeight[zb0001], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0002 := range (*z).SignedWeight {
+ (*z).SignedWeight[zb0002], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0001)
+ err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0002)
return
}
}
}
- if zb0009 > 0 {
- zb0009--
+ if zb0012 > 0 {
+ zb0012--
{
- var zb0016 []byte
- var zb0017 int
- zb0017, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0020 []byte
+ var zb0021 int
+ zb0021, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- if zb0017 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0017), uint64(maxBitmaskSize))
+ if zb0021 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0021), uint64(maxBitmaskSize))
return
}
- zb0016, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSignedWeight))
+ zb0020, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- (*z).BitmaskSignedWeight = bitmask(zb0016)
+ (*z).BitmaskSignedWeight = bitmask(zb0020)
}
}
- if zb0009 > 0 {
- zb0009--
- var zb0018 int
- var zb0019 bool
- zb0018, zb0019, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0012 > 0 {
+ zb0012--
+ var zb0022 int
+ var zb0023 bool
+ zb0022, zb0023, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0018 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0018), uint64(maxEncodedTransactionGroups))
+ if zb0022 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0022), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0019 {
+ if zb0023 {
(*z).SigProofs = nil
- } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0018 {
- (*z).SigProofs = ((*z).SigProofs)[:zb0018]
+ } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0022 {
+ (*z).SigProofs = ((*z).SigProofs)[:zb0022]
} else {
- (*z).SigProofs = make([]certProofs, zb0018)
+ (*z).SigProofs = make([]certProofs, zb0022)
}
- for zb0002 := range (*z).SigProofs {
- var zb0020 int
- var zb0021 bool
- zb0020, zb0021, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0003 := range (*z).SigProofs {
+ var zb0024 int
+ var zb0025 bool
+ zb0024, zb0025, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0002)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0003)
return
}
- if zb0020 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0020), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0002)
+ if zb0024 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0024), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0003)
return
}
- if zb0021 {
- (*z).SigProofs[zb0002] = nil
- } else if (*z).SigProofs[zb0002] != nil && cap((*z).SigProofs[zb0002]) >= zb0020 {
- (*z).SigProofs[zb0002] = ((*z).SigProofs[zb0002])[:zb0020]
+ if zb0025 {
+ (*z).SigProofs[zb0003] = nil
+ } else if (*z).SigProofs[zb0003] != nil && cap((*z).SigProofs[zb0003]) >= zb0024 {
+ (*z).SigProofs[zb0003] = ((*z).SigProofs[zb0003])[:zb0024]
} else {
- (*z).SigProofs[zb0002] = make(certProofs, zb0020)
+ (*z).SigProofs[zb0003] = make(certProofs, zb0024)
}
- for zb0003 := range (*z).SigProofs[zb0002] {
- bts, err = (*z).SigProofs[zb0002][zb0003].UnmarshalMsg(bts)
+ for zb0004 := range (*z).SigProofs[zb0003] {
+ bts, err = (*z).SigProofs[zb0003][zb0004].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0002, zb0003)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0003, zb0004)
return
}
}
}
}
- if zb0009 > 0 {
- zb0009--
+ if zb0012 > 0 {
+ zb0012--
{
- var zb0022 []byte
- var zb0023 int
- zb0023, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0026 []byte
+ var zb0027 int
+ zb0027, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- if zb0023 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0023), uint64(maxBitmaskSize))
+ if zb0027 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0027), uint64(maxBitmaskSize))
return
}
- zb0022, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigProofs))
+ zb0026, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- (*z).BitmaskSigProofs = bitmask(zb0022)
+ (*z).BitmaskSigProofs = bitmask(zb0026)
}
}
- if zb0009 > 0 {
- zb0009--
- var zb0024 int
- var zb0025 bool
- zb0024, zb0025, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0012 > 0 {
+ zb0012--
+ var zb0028 int
+ var zb0029 bool
+ zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0028 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0028), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0029 {
+ (*z).SigProofHashTypes = nil
+ } else if (*z).SigProofHashTypes != nil && cap((*z).SigProofHashTypes) >= zb0028 {
+ (*z).SigProofHashTypes = ((*z).SigProofHashTypes)[:zb0028]
+ } else {
+ (*z).SigProofHashTypes = make([]uint64, zb0028)
+ }
+ for zb0005 := range (*z).SigProofHashTypes {
+ (*z).SigProofHashTypes[zb0005], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes", zb0005)
+ return
+ }
+ }
+ }
+ if zb0012 > 0 {
+ zb0012--
+ {
+ var zb0030 []byte
+ var zb0031 int
+ zb0031, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ if zb0031 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0031), uint64(maxBitmaskSize))
+ return
+ }
+ zb0030, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ (*z).BitmaskSigsHash = bitmask(zb0030)
+ }
+ }
+ if zb0012 > 0 {
+ zb0012--
+ var zb0032 int
+ var zb0033 bool
+ zb0032, zb0033, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0024 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0024), uint64(maxEncodedTransactionGroups))
+ if zb0032 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0032), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0025 {
+ if zb0033 {
(*z).PartProofs = nil
- } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0024 {
- (*z).PartProofs = ((*z).PartProofs)[:zb0024]
+ } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0032 {
+ (*z).PartProofs = ((*z).PartProofs)[:zb0032]
} else {
- (*z).PartProofs = make([]certProofs, zb0024)
+ (*z).PartProofs = make([]certProofs, zb0032)
}
- for zb0004 := range (*z).PartProofs {
- var zb0026 int
- var zb0027 bool
- zb0026, zb0027, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0006 := range (*z).PartProofs {
+ var zb0034 int
+ var zb0035 bool
+ zb0034, zb0035, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0004)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006)
return
}
- if zb0026 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0026), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0004)
+ if zb0034 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0034), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006)
return
}
- if zb0027 {
- (*z).PartProofs[zb0004] = nil
- } else if (*z).PartProofs[zb0004] != nil && cap((*z).PartProofs[zb0004]) >= zb0026 {
- (*z).PartProofs[zb0004] = ((*z).PartProofs[zb0004])[:zb0026]
+ if zb0035 {
+ (*z).PartProofs[zb0006] = nil
+ } else if (*z).PartProofs[zb0006] != nil && cap((*z).PartProofs[zb0006]) >= zb0034 {
+ (*z).PartProofs[zb0006] = ((*z).PartProofs[zb0006])[:zb0034]
} else {
- (*z).PartProofs[zb0004] = make(certProofs, zb0026)
+ (*z).PartProofs[zb0006] = make(certProofs, zb0034)
}
- for zb0005 := range (*z).PartProofs[zb0004] {
- bts, err = (*z).PartProofs[zb0004][zb0005].UnmarshalMsg(bts)
+ for zb0007 := range (*z).PartProofs[zb0006] {
+ bts, err = (*z).PartProofs[zb0006][zb0007].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0004, zb0005)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006, zb0007)
return
}
}
}
}
- if zb0009 > 0 {
- zb0009--
+ if zb0012 > 0 {
+ zb0012--
{
- var zb0028 []byte
- var zb0029 int
- zb0029, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0036 []byte
+ var zb0037 int
+ zb0037, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- if zb0029 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0029), uint64(maxBitmaskSize))
+ if zb0037 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0037), uint64(maxBitmaskSize))
return
}
- zb0028, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartProofs))
+ zb0036, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- (*z).BitmaskPartProofs = bitmask(zb0028)
+ (*z).BitmaskPartProofs = bitmask(zb0036)
}
}
- if zb0009 > 0 {
- zb0009--
- var zb0030 int
- var zb0031 bool
- zb0030, zb0031, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0012 > 0 {
+ zb0012--
+ var zb0038 int
+ var zb0039 bool
+ zb0038, zb0039, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0038 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0038), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0039 {
+ (*z).PartProofHashTypes = nil
+ } else if (*z).PartProofHashTypes != nil && cap((*z).PartProofHashTypes) >= zb0038 {
+ (*z).PartProofHashTypes = ((*z).PartProofHashTypes)[:zb0038]
+ } else {
+ (*z).PartProofHashTypes = make([]uint64, zb0038)
+ }
+ for zb0008 := range (*z).PartProofHashTypes {
+ (*z).PartProofHashTypes[zb0008], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes", zb0008)
+ return
+ }
+ }
+ }
+ if zb0012 > 0 {
+ zb0012--
+ {
+ var zb0040 []byte
+ var zb0041 int
+ zb0041, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ if zb0041 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0041), uint64(maxBitmaskSize))
+ return
+ }
+ zb0040, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ (*z).BitmaskPartHash = bitmask(zb0040)
+ }
+ }
+ if zb0012 > 0 {
+ zb0012--
+ var zb0042 int
+ var zb0043 bool
+ zb0042, zb0043, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0030 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0030), uint64(maxEncodedTransactionGroups))
+ if zb0042 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0042), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0031 {
+ if zb0043 {
(*z).Reveals = nil
- } else if (*z).Reveals != nil && cap((*z).Reveals) >= zb0030 {
- (*z).Reveals = ((*z).Reveals)[:zb0030]
+ } else if (*z).Reveals != nil && cap((*z).Reveals) >= zb0042 {
+ (*z).Reveals = ((*z).Reveals)[:zb0042]
} else {
- (*z).Reveals = make([]revealMap, zb0030)
+ (*z).Reveals = make([]revealMap, zb0042)
}
- for zb0006 := range (*z).Reveals {
- var zb0032 int
- var zb0033 bool
- zb0032, zb0033, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0009 := range (*z).Reveals {
+ var zb0044 int
+ var zb0045 bool
+ zb0044, zb0045, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0006)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0009)
return
}
- if zb0032 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0032), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0006)
+ if zb0044 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0044), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0009)
return
}
- if zb0033 {
- (*z).Reveals[zb0006] = nil
- } else if (*z).Reveals[zb0006] == nil {
- (*z).Reveals[zb0006] = make(revealMap, zb0032)
+ if zb0045 {
+ (*z).Reveals[zb0009] = nil
+ } else if (*z).Reveals[zb0009] == nil {
+ (*z).Reveals[zb0009] = make(revealMap, zb0044)
}
- for zb0032 > 0 {
- var zb0007 uint64
- var zb0008 compactcert.Reveal
- zb0032--
- zb0007, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0044 > 0 {
+ var zb0010 uint64
+ var zb0011 compactcert.Reveal
+ zb0044--
+ zb0010, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0006)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0009)
return
}
- bts, err = zb0008.UnmarshalMsg(bts)
+ bts, err = zb0011.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0006, zb0007)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0009, zb0010)
return
}
- (*z).Reveals[zb0006][zb0007] = zb0008
+ (*z).Reveals[zb0009][zb0010] = zb0011
}
}
}
- if zb0009 > 0 {
- zb0009--
+ if zb0012 > 0 {
+ zb0012--
{
- var zb0034 []byte
- var zb0035 int
- zb0035, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0046 []byte
+ var zb0047 int
+ zb0047, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- if zb0035 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0035), uint64(maxBitmaskSize))
+ if zb0047 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0047), uint64(maxBitmaskSize))
return
}
- zb0034, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskReveals))
+ zb0046, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- (*z).BitmaskReveals = bitmask(zb0034)
+ (*z).BitmaskReveals = bitmask(zb0046)
}
}
- if zb0009 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0009)
+ if zb0012 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0012)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -7039,11 +7209,11 @@ func (z *encodedCert) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err)
return
}
- if zb0010 {
+ if zb0013 {
(*z) = encodedCert{}
}
- for zb0009 > 0 {
- zb0009--
+ for zb0012 > 0 {
+ zb0012--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -7051,298 +7221,403 @@ func (z *encodedCert) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
switch string(field) {
case "certc":
- var zb0036 int
- zb0036, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0048 int
+ var zb0049 bool
+ zb0048, zb0049, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigCommit")
return
}
- if zb0036 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0036), uint64(maxAddressBytes))
- return
- }
- (*z).SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).SigCommit)
- if err != nil {
+ if zb0048 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0048), uint64(maxAddressBytes))
err = msgp.WrapError(err, "SigCommit")
return
}
+ if zb0049 {
+ (*z).SigCommit = nil
+ } else if (*z).SigCommit != nil && cap((*z).SigCommit) >= zb0048 {
+ (*z).SigCommit = ((*z).SigCommit)[:zb0048]
+ } else {
+ (*z).SigCommit = make([]crypto.GenericDigest, zb0048)
+ }
+ for zb0001 := range (*z).SigCommit {
+ bts, err = (*z).SigCommit[zb0001].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigCommit", zb0001)
+ return
+ }
+ }
case "certcbm":
{
- var zb0037 []byte
- var zb0038 int
- zb0038, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0050 []byte
+ var zb0051 int
+ zb0051, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- if zb0038 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0038), uint64(maxBitmaskSize))
+ if zb0051 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0051), uint64(maxBitmaskSize))
return
}
- zb0037, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigCommit))
+ zb0050, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- (*z).BitmaskSigCommit = bitmask(zb0037)
+ (*z).BitmaskSigCommit = bitmask(zb0050)
}
case "certw":
- var zb0039 int
- var zb0040 bool
- zb0039, zb0040, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0052 int
+ var zb0053 bool
+ zb0052, zb0053, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0039 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0039), uint64(maxEncodedTransactionGroups))
+ if zb0052 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0052), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0040 {
+ if zb0053 {
(*z).SignedWeight = nil
- } else if (*z).SignedWeight != nil && cap((*z).SignedWeight) >= zb0039 {
- (*z).SignedWeight = ((*z).SignedWeight)[:zb0039]
+ } else if (*z).SignedWeight != nil && cap((*z).SignedWeight) >= zb0052 {
+ (*z).SignedWeight = ((*z).SignedWeight)[:zb0052]
} else {
- (*z).SignedWeight = make([]uint64, zb0039)
+ (*z).SignedWeight = make([]uint64, zb0052)
}
- for zb0001 := range (*z).SignedWeight {
- (*z).SignedWeight[zb0001], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0002 := range (*z).SignedWeight {
+ (*z).SignedWeight[zb0002], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SignedWeight", zb0001)
+ err = msgp.WrapError(err, "SignedWeight", zb0002)
return
}
}
case "certwbm":
{
- var zb0041 []byte
- var zb0042 int
- zb0042, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0054 []byte
+ var zb0055 int
+ zb0055, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- if zb0042 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0042), uint64(maxBitmaskSize))
+ if zb0055 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0055), uint64(maxBitmaskSize))
return
}
- zb0041, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSignedWeight))
+ zb0054, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- (*z).BitmaskSignedWeight = bitmask(zb0041)
+ (*z).BitmaskSignedWeight = bitmask(zb0054)
}
case "certS":
- var zb0043 int
- var zb0044 bool
- zb0043, zb0044, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0056 int
+ var zb0057 bool
+ zb0056, zb0057, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0043 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0043), uint64(maxEncodedTransactionGroups))
+ if zb0056 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0056), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0044 {
+ if zb0057 {
(*z).SigProofs = nil
- } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0043 {
- (*z).SigProofs = ((*z).SigProofs)[:zb0043]
+ } else if (*z).SigProofs != nil && cap((*z).SigProofs) >= zb0056 {
+ (*z).SigProofs = ((*z).SigProofs)[:zb0056]
} else {
- (*z).SigProofs = make([]certProofs, zb0043)
+ (*z).SigProofs = make([]certProofs, zb0056)
}
- for zb0002 := range (*z).SigProofs {
- var zb0045 int
- var zb0046 bool
- zb0045, zb0046, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0003 := range (*z).SigProofs {
+ var zb0058 int
+ var zb0059 bool
+ zb0058, zb0059, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0002)
+ err = msgp.WrapError(err, "SigProofs", zb0003)
return
}
- if zb0045 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0045), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs", zb0002)
+ if zb0058 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0058), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "SigProofs", zb0003)
return
}
- if zb0046 {
- (*z).SigProofs[zb0002] = nil
- } else if (*z).SigProofs[zb0002] != nil && cap((*z).SigProofs[zb0002]) >= zb0045 {
- (*z).SigProofs[zb0002] = ((*z).SigProofs[zb0002])[:zb0045]
+ if zb0059 {
+ (*z).SigProofs[zb0003] = nil
+ } else if (*z).SigProofs[zb0003] != nil && cap((*z).SigProofs[zb0003]) >= zb0058 {
+ (*z).SigProofs[zb0003] = ((*z).SigProofs[zb0003])[:zb0058]
} else {
- (*z).SigProofs[zb0002] = make(certProofs, zb0045)
+ (*z).SigProofs[zb0003] = make(certProofs, zb0058)
}
- for zb0003 := range (*z).SigProofs[zb0002] {
- bts, err = (*z).SigProofs[zb0002][zb0003].UnmarshalMsg(bts)
+ for zb0004 := range (*z).SigProofs[zb0003] {
+ bts, err = (*z).SigProofs[zb0003][zb0004].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0002, zb0003)
+ err = msgp.WrapError(err, "SigProofs", zb0003, zb0004)
return
}
}
}
case "certSbm":
{
- var zb0047 []byte
- var zb0048 int
- zb0048, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0060 []byte
+ var zb0061 int
+ zb0061, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- if zb0048 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0048), uint64(maxBitmaskSize))
+ if zb0061 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0061), uint64(maxBitmaskSize))
return
}
- zb0047, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigProofs))
+ zb0060, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- (*z).BitmaskSigProofs = bitmask(zb0047)
+ (*z).BitmaskSigProofs = bitmask(zb0060)
+ }
+ case "certSH":
+ var zb0062 int
+ var zb0063 bool
+ zb0062, zb0063, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0062 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0062), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0063 {
+ (*z).SigProofHashTypes = nil
+ } else if (*z).SigProofHashTypes != nil && cap((*z).SigProofHashTypes) >= zb0062 {
+ (*z).SigProofHashTypes = ((*z).SigProofHashTypes)[:zb0062]
+ } else {
+ (*z).SigProofHashTypes = make([]uint64, zb0062)
+ }
+ for zb0005 := range (*z).SigProofHashTypes {
+ (*z).SigProofHashTypes[zb0005], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes", zb0005)
+ return
+ }
+ }
+ case "certSHbm":
+ {
+ var zb0064 []byte
+ var zb0065 int
+ zb0065, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ if zb0065 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0065), uint64(maxBitmaskSize))
+ return
+ }
+ zb0064, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ (*z).BitmaskSigsHash = bitmask(zb0064)
}
case "certP":
- var zb0049 int
- var zb0050 bool
- zb0049, zb0050, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0066 int
+ var zb0067 bool
+ zb0066, zb0067, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0049 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0049), uint64(maxEncodedTransactionGroups))
+ if zb0066 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0066), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0050 {
+ if zb0067 {
(*z).PartProofs = nil
- } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0049 {
- (*z).PartProofs = ((*z).PartProofs)[:zb0049]
+ } else if (*z).PartProofs != nil && cap((*z).PartProofs) >= zb0066 {
+ (*z).PartProofs = ((*z).PartProofs)[:zb0066]
} else {
- (*z).PartProofs = make([]certProofs, zb0049)
+ (*z).PartProofs = make([]certProofs, zb0066)
}
- for zb0004 := range (*z).PartProofs {
- var zb0051 int
- var zb0052 bool
- zb0051, zb0052, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0006 := range (*z).PartProofs {
+ var zb0068 int
+ var zb0069 bool
+ zb0068, zb0069, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0004)
+ err = msgp.WrapError(err, "PartProofs", zb0006)
return
}
- if zb0051 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0051), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs", zb0004)
+ if zb0068 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0068), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "PartProofs", zb0006)
return
}
- if zb0052 {
- (*z).PartProofs[zb0004] = nil
- } else if (*z).PartProofs[zb0004] != nil && cap((*z).PartProofs[zb0004]) >= zb0051 {
- (*z).PartProofs[zb0004] = ((*z).PartProofs[zb0004])[:zb0051]
+ if zb0069 {
+ (*z).PartProofs[zb0006] = nil
+ } else if (*z).PartProofs[zb0006] != nil && cap((*z).PartProofs[zb0006]) >= zb0068 {
+ (*z).PartProofs[zb0006] = ((*z).PartProofs[zb0006])[:zb0068]
} else {
- (*z).PartProofs[zb0004] = make(certProofs, zb0051)
+ (*z).PartProofs[zb0006] = make(certProofs, zb0068)
}
- for zb0005 := range (*z).PartProofs[zb0004] {
- bts, err = (*z).PartProofs[zb0004][zb0005].UnmarshalMsg(bts)
+ for zb0007 := range (*z).PartProofs[zb0006] {
+ bts, err = (*z).PartProofs[zb0006][zb0007].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0004, zb0005)
+ err = msgp.WrapError(err, "PartProofs", zb0006, zb0007)
return
}
}
}
case "certPbm":
{
- var zb0053 []byte
- var zb0054 int
- zb0054, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0070 []byte
+ var zb0071 int
+ zb0071, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- if zb0054 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0054), uint64(maxBitmaskSize))
+ if zb0071 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0071), uint64(maxBitmaskSize))
return
}
- zb0053, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartProofs))
+ zb0070, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- (*z).BitmaskPartProofs = bitmask(zb0053)
+ (*z).BitmaskPartProofs = bitmask(zb0070)
+ }
+ case "certPH":
+ var zb0072 int
+ var zb0073 bool
+ zb0072, zb0073, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0072 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0072), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0073 {
+ (*z).PartProofHashTypes = nil
+ } else if (*z).PartProofHashTypes != nil && cap((*z).PartProofHashTypes) >= zb0072 {
+ (*z).PartProofHashTypes = ((*z).PartProofHashTypes)[:zb0072]
+ } else {
+ (*z).PartProofHashTypes = make([]uint64, zb0072)
+ }
+ for zb0008 := range (*z).PartProofHashTypes {
+ (*z).PartProofHashTypes[zb0008], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes", zb0008)
+ return
+ }
+ }
+ case "certPHbm":
+ {
+ var zb0074 []byte
+ var zb0075 int
+ zb0075, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ if zb0075 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0075), uint64(maxBitmaskSize))
+ return
+ }
+ zb0074, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ (*z).BitmaskPartHash = bitmask(zb0074)
}
case "certr":
- var zb0055 int
- var zb0056 bool
- zb0055, zb0056, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0076 int
+ var zb0077 bool
+ zb0076, zb0077, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0055 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0055), uint64(maxEncodedTransactionGroups))
+ if zb0076 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0076), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0056 {
+ if zb0077 {
(*z).Reveals = nil
- } else if (*z).Reveals != nil && cap((*z).Reveals) >= zb0055 {
- (*z).Reveals = ((*z).Reveals)[:zb0055]
+ } else if (*z).Reveals != nil && cap((*z).Reveals) >= zb0076 {
+ (*z).Reveals = ((*z).Reveals)[:zb0076]
} else {
- (*z).Reveals = make([]revealMap, zb0055)
+ (*z).Reveals = make([]revealMap, zb0076)
}
- for zb0006 := range (*z).Reveals {
- var zb0057 int
- var zb0058 bool
- zb0057, zb0058, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0009 := range (*z).Reveals {
+ var zb0078 int
+ var zb0079 bool
+ zb0078, zb0079, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0006)
+ err = msgp.WrapError(err, "Reveals", zb0009)
return
}
- if zb0057 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0057), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "Reveals", zb0006)
+ if zb0078 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0078), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "Reveals", zb0009)
return
}
- if zb0058 {
- (*z).Reveals[zb0006] = nil
- } else if (*z).Reveals[zb0006] == nil {
- (*z).Reveals[zb0006] = make(revealMap, zb0057)
+ if zb0079 {
+ (*z).Reveals[zb0009] = nil
+ } else if (*z).Reveals[zb0009] == nil {
+ (*z).Reveals[zb0009] = make(revealMap, zb0078)
}
- for zb0057 > 0 {
- var zb0007 uint64
- var zb0008 compactcert.Reveal
- zb0057--
- zb0007, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0078 > 0 {
+ var zb0010 uint64
+ var zb0011 compactcert.Reveal
+ zb0078--
+ zb0010, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0006)
+ err = msgp.WrapError(err, "Reveals", zb0009)
return
}
- bts, err = zb0008.UnmarshalMsg(bts)
+ bts, err = zb0011.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0006, zb0007)
+ err = msgp.WrapError(err, "Reveals", zb0009, zb0010)
return
}
- (*z).Reveals[zb0006][zb0007] = zb0008
+ (*z).Reveals[zb0009][zb0010] = zb0011
}
}
case "certrbm":
{
- var zb0059 []byte
- var zb0060 int
- zb0060, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0080 []byte
+ var zb0081 int
+ zb0081, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- if zb0060 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0060), uint64(maxBitmaskSize))
+ if zb0081 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0081), uint64(maxBitmaskSize))
return
}
- zb0059, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskReveals))
+ zb0080, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- (*z).BitmaskReveals = bitmask(zb0059)
+ (*z).BitmaskReveals = bitmask(zb0080)
}
default:
err = msgp.ErrNoField(string(field))
@@ -7364,28 +7639,32 @@ func (_ *encodedCert) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *encodedCert) Msgsize() (s int) {
- s = 1 + 6 + msgp.BytesPrefixSize + len((*z).SigCommit) + 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
- for zb0002 := range (*z).SigProofs {
+ s = 1 + 6 + msgp.ArrayHeaderSize
+ for zb0001 := range (*z).SigCommit {
+ s += (*z).SigCommit[zb0001].Msgsize()
+ }
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
+ for zb0003 := range (*z).SigProofs {
s += msgp.ArrayHeaderSize
- for zb0003 := range (*z).SigProofs[zb0002] {
- s += (*z).SigProofs[zb0002][zb0003].Msgsize()
+ for zb0004 := range (*z).SigProofs[zb0003] {
+ s += (*z).SigProofs[zb0003][zb0004].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSigProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0004 := range (*z).PartProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSigProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).SigProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskSigsHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0006 := range (*z).PartProofs {
s += msgp.ArrayHeaderSize
- for zb0005 := range (*z).PartProofs[zb0004] {
- s += (*z).PartProofs[zb0004][zb0005].Msgsize()
+ for zb0007 := range (*z).PartProofs[zb0006] {
+ s += (*z).PartProofs[zb0006][zb0007].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskPartProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0006 := range (*z).Reveals {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskPartProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).PartProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskPartHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0009 := range (*z).Reveals {
s += msgp.MapHeaderSize
- if (*z).Reveals[zb0006] != nil {
- for zb0007, zb0008 := range (*z).Reveals[zb0006] {
- _ = zb0007
- _ = zb0008
- s += 0 + msgp.Uint64Size + zb0008.Msgsize()
+ if (*z).Reveals[zb0009] != nil {
+ for zb0010, zb0011 := range (*z).Reveals[zb0009] {
+ _ = zb0010
+ _ = zb0011
+ s += 0 + msgp.Uint64Size + zb0011.Msgsize()
}
}
}
@@ -7395,75 +7674,91 @@ func (z *encodedCert) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *encodedCert) MsgIsZero() bool {
- return (len((*z).SigCommit) == 0) && (len((*z).BitmaskSigCommit) == 0) && (len((*z).SignedWeight) == 0) && (len((*z).BitmaskSignedWeight) == 0) && (len((*z).SigProofs) == 0) && (len((*z).BitmaskSigProofs) == 0) && (len((*z).PartProofs) == 0) && (len((*z).BitmaskPartProofs) == 0) && (len((*z).Reveals) == 0) && (len((*z).BitmaskReveals) == 0)
+ return (len((*z).SigCommit) == 0) && (len((*z).BitmaskSigCommit) == 0) && (len((*z).SignedWeight) == 0) && (len((*z).BitmaskSignedWeight) == 0) && (len((*z).SigProofs) == 0) && (len((*z).BitmaskSigProofs) == 0) && (len((*z).SigProofHashTypes) == 0) && (len((*z).BitmaskSigsHash) == 0) && (len((*z).PartProofs) == 0) && (len((*z).BitmaskPartProofs) == 0) && (len((*z).PartProofHashTypes) == 0) && (len((*z).BitmaskPartHash) == 0) && (len((*z).Reveals) == 0) && (len((*z).BitmaskReveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0011Len := uint32(14)
- var zb0011Mask uint16 /* 16 bits */
+ zb0014Len := uint32(18)
+ var zb0014Mask uint32 /* 20 bits */
if len((*z).encodedCert.PartProofs) == 0 {
- zb0011Len--
- zb0011Mask |= 0x4
+ zb0014Len--
+ zb0014Mask |= 0x4
+ }
+ if len((*z).encodedCert.PartProofHashTypes) == 0 {
+ zb0014Len--
+ zb0014Mask |= 0x8
+ }
+ if len((*z).encodedCert.BitmaskPartHash) == 0 {
+ zb0014Len--
+ zb0014Mask |= 0x10
}
if len((*z).encodedCert.BitmaskPartProofs) == 0 {
- zb0011Len--
- zb0011Mask |= 0x8
+ zb0014Len--
+ zb0014Mask |= 0x20
}
if len((*z).encodedCert.SigProofs) == 0 {
- zb0011Len--
- zb0011Mask |= 0x10
+ zb0014Len--
+ zb0014Mask |= 0x40
+ }
+ if len((*z).encodedCert.SigProofHashTypes) == 0 {
+ zb0014Len--
+ zb0014Mask |= 0x80
+ }
+ if len((*z).encodedCert.BitmaskSigsHash) == 0 {
+ zb0014Len--
+ zb0014Mask |= 0x100
}
if len((*z).encodedCert.BitmaskSigProofs) == 0 {
- zb0011Len--
- zb0011Mask |= 0x20
+ zb0014Len--
+ zb0014Mask |= 0x200
}
if len((*z).encodedCert.SigCommit) == 0 {
- zb0011Len--
- zb0011Mask |= 0x40
+ zb0014Len--
+ zb0014Mask |= 0x400
}
if len((*z).encodedCert.BitmaskSigCommit) == 0 {
- zb0011Len--
- zb0011Mask |= 0x80
+ zb0014Len--
+ zb0014Mask |= 0x800
}
if len((*z).encodedCert.Reveals) == 0 {
- zb0011Len--
- zb0011Mask |= 0x100
+ zb0014Len--
+ zb0014Mask |= 0x1000
}
if len((*z).encodedCert.BitmaskReveals) == 0 {
- zb0011Len--
- zb0011Mask |= 0x200
+ zb0014Len--
+ zb0014Mask |= 0x2000
}
if len((*z).CertRound) == 0 {
- zb0011Len--
- zb0011Mask |= 0x400
+ zb0014Len--
+ zb0014Mask |= 0x4000
}
if len((*z).BitmaskCertRound) == 0 {
- zb0011Len--
- zb0011Mask |= 0x800
+ zb0014Len--
+ zb0014Mask |= 0x8000
}
if len((*z).CertType) == 0 {
- zb0011Len--
- zb0011Mask |= 0x1000
+ zb0014Len--
+ zb0014Mask |= 0x10000
}
if len((*z).BitmaskCertType) == 0 {
- zb0011Len--
- zb0011Mask |= 0x2000
+ zb0014Len--
+ zb0014Mask |= 0x20000
}
if len((*z).encodedCert.SignedWeight) == 0 {
- zb0011Len--
- zb0011Mask |= 0x4000
+ zb0014Len--
+ zb0014Mask |= 0x40000
}
if len((*z).encodedCert.BitmaskSignedWeight) == 0 {
- zb0011Len--
- zb0011Mask |= 0x8000
+ zb0014Len--
+ zb0014Mask |= 0x80000
}
- // variable map header, size zb0011Len
- o = append(o, 0x80|uint8(zb0011Len))
- if zb0011Len != 0 {
- if (zb0011Mask & 0x4) == 0 { // if not empty
+ // variable map header, size zb0014Len
+ o = msgp.AppendMapHeader(o, zb0014Len)
+ if zb0014Len != 0 {
+ if (zb0014Mask & 0x4) == 0 { // if not empty
// string "certP"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x50)
if (*z).encodedCert.PartProofs == nil {
@@ -7471,23 +7766,40 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.PartProofs)))
}
- for zb0006 := range (*z).encodedCert.PartProofs {
- if (*z).encodedCert.PartProofs[zb0006] == nil {
+ for zb0008 := range (*z).encodedCert.PartProofs {
+ if (*z).encodedCert.PartProofs[zb0008] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.PartProofs[zb0006])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.PartProofs[zb0008])))
}
- for zb0007 := range (*z).encodedCert.PartProofs[zb0006] {
- o = (*z).encodedCert.PartProofs[zb0006][zb0007].MarshalMsg(o)
+ for zb0009 := range (*z).encodedCert.PartProofs[zb0008] {
+ o = (*z).encodedCert.PartProofs[zb0008][zb0009].MarshalMsg(o)
}
}
}
- if (zb0011Mask & 0x8) == 0 { // if not empty
+ if (zb0014Mask & 0x8) == 0 { // if not empty
+ // string "certPH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48)
+ if (*z).encodedCert.PartProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.PartProofHashTypes)))
+ }
+ for zb0010 := range (*z).encodedCert.PartProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedCert.PartProofHashTypes[zb0010])
+ }
+ }
+ if (zb0014Mask & 0x10) == 0 { // if not empty
+ // string "certPHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskPartHash))
+ }
+ if (zb0014Mask & 0x20) == 0 { // if not empty
// string "certPbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x50, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskPartProofs))
}
- if (zb0011Mask & 0x10) == 0 { // if not empty
+ if (zb0014Mask & 0x40) == 0 { // if not empty
// string "certS"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x53)
if (*z).encodedCert.SigProofs == nil {
@@ -7495,33 +7807,57 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SigProofs)))
}
- for zb0004 := range (*z).encodedCert.SigProofs {
- if (*z).encodedCert.SigProofs[zb0004] == nil {
+ for zb0005 := range (*z).encodedCert.SigProofs {
+ if (*z).encodedCert.SigProofs[zb0005] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SigProofs[zb0004])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SigProofs[zb0005])))
}
- for zb0005 := range (*z).encodedCert.SigProofs[zb0004] {
- o = (*z).encodedCert.SigProofs[zb0004][zb0005].MarshalMsg(o)
+ for zb0006 := range (*z).encodedCert.SigProofs[zb0005] {
+ o = (*z).encodedCert.SigProofs[zb0005][zb0006].MarshalMsg(o)
}
}
}
- if (zb0011Mask & 0x20) == 0 { // if not empty
+ if (zb0014Mask & 0x80) == 0 { // if not empty
+ // string "certSH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48)
+ if (*z).encodedCert.SigProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SigProofHashTypes)))
+ }
+ for zb0007 := range (*z).encodedCert.SigProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedCert.SigProofHashTypes[zb0007])
+ }
+ }
+ if (zb0014Mask & 0x100) == 0 { // if not empty
+ // string "certSHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskSigsHash))
+ }
+ if (zb0014Mask & 0x200) == 0 { // if not empty
// string "certSbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x53, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskSigProofs))
}
- if (zb0011Mask & 0x40) == 0 { // if not empty
+ if (zb0014Mask & 0x400) == 0 { // if not empty
// string "certc"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x63)
- o = msgp.AppendBytes(o, (*z).encodedCert.SigCommit)
+ if (*z).encodedCert.SigCommit == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SigCommit)))
+ }
+ for zb0003 := range (*z).encodedCert.SigCommit {
+ o = (*z).encodedCert.SigCommit[zb0003].MarshalMsg(o)
+ }
}
- if (zb0011Mask & 0x80) == 0 { // if not empty
+ if (zb0014Mask & 0x800) == 0 { // if not empty
// string "certcbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskSigCommit))
}
- if (zb0011Mask & 0x100) == 0 { // if not empty
+ if (zb0014Mask & 0x1000) == 0 { // if not empty
// string "certr"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x72)
if (*z).encodedCert.Reveals == nil {
@@ -7529,31 +7865,31 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.Reveals)))
}
- for zb0008 := range (*z).encodedCert.Reveals {
- if (*z).encodedCert.Reveals[zb0008] == nil {
+ for zb0011 := range (*z).encodedCert.Reveals {
+ if (*z).encodedCert.Reveals[zb0011] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).encodedCert.Reveals[zb0008])))
+ o = msgp.AppendMapHeader(o, uint32(len((*z).encodedCert.Reveals[zb0011])))
}
- zb0009_keys := make([]uint64, 0, len((*z).encodedCert.Reveals[zb0008]))
- for zb0009 := range (*z).encodedCert.Reveals[zb0008] {
- zb0009_keys = append(zb0009_keys, zb0009)
+ zb0012_keys := make([]uint64, 0, len((*z).encodedCert.Reveals[zb0011]))
+ for zb0012 := range (*z).encodedCert.Reveals[zb0011] {
+ zb0012_keys = append(zb0012_keys, zb0012)
}
- sort.Sort(SortUint64(zb0009_keys))
- for _, zb0009 := range zb0009_keys {
- zb0010 := (*z).encodedCert.Reveals[zb0008][zb0009]
- _ = zb0010
- o = msgp.AppendUint64(o, zb0009)
- o = zb0010.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0012_keys))
+ for _, zb0012 := range zb0012_keys {
+ zb0013 := (*z).encodedCert.Reveals[zb0011][zb0012]
+ _ = zb0013
+ o = msgp.AppendUint64(o, zb0012)
+ o = zb0013.MarshalMsg(o)
}
}
}
- if (zb0011Mask & 0x200) == 0 { // if not empty
+ if (zb0014Mask & 0x2000) == 0 { // if not empty
// string "certrbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskReveals))
}
- if (zb0011Mask & 0x400) == 0 { // if not empty
+ if (zb0014Mask & 0x4000) == 0 { // if not empty
// string "certrnd"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64)
if (*z).CertRound == nil {
@@ -7565,12 +7901,12 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
o = (*z).CertRound[zb0001].MarshalMsg(o)
}
}
- if (zb0011Mask & 0x800) == 0 { // if not empty
+ if (zb0014Mask & 0x8000) == 0 { // if not empty
// string "certrndbm"
o = append(o, 0xa9, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskCertRound))
}
- if (zb0011Mask & 0x1000) == 0 { // if not empty
+ if (zb0014Mask & 0x10000) == 0 { // if not empty
// string "certtype"
o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65)
if (*z).CertType == nil {
@@ -7582,12 +7918,12 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
o = (*z).CertType[zb0002].MarshalMsg(o)
}
}
- if (zb0011Mask & 0x2000) == 0 { // if not empty
+ if (zb0014Mask & 0x20000) == 0 { // if not empty
// string "certtypebm"
o = append(o, 0xaa, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskCertType))
}
- if (zb0011Mask & 0x4000) == 0 { // if not empty
+ if (zb0014Mask & 0x40000) == 0 { // if not empty
// string "certw"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x77)
if (*z).encodedCert.SignedWeight == nil {
@@ -7595,11 +7931,11 @@ func (z *encodedCompactCertTxnFields) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCert.SignedWeight)))
}
- for zb0003 := range (*z).encodedCert.SignedWeight {
- o = msgp.AppendUint64(o, (*z).encodedCert.SignedWeight[zb0003])
+ for zb0004 := range (*z).encodedCert.SignedWeight {
+ o = msgp.AppendUint64(o, (*z).encodedCert.SignedWeight[zb0004])
}
}
- if (zb0011Mask & 0x8000) == 0 { // if not empty
+ if (zb0014Mask & 0x80000) == 0 { // if not empty
// string "certwbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x77, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCert.BitmaskSignedWeight))
@@ -7617,35 +7953,35 @@ func (_ *encodedCompactCertTxnFields) CanMarshalMsg(z interface{}) bool {
func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0011 int
- var zb0012 bool
- zb0011, zb0012, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0014 int
+ var zb0015 bool
+ zb0014, zb0015, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0011, zb0012, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0014, zb0015, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0011 > 0 {
- zb0011--
- var zb0013 int
- var zb0014 bool
- zb0013, zb0014, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0016 int
+ var zb0017 bool
+ zb0016, zb0017, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0013 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0013), uint64(maxEncodedTransactionGroups))
+ if zb0016 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0016), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0014 {
+ if zb0017 {
(*z).CertRound = nil
- } else if (*z).CertRound != nil && cap((*z).CertRound) >= zb0013 {
- (*z).CertRound = ((*z).CertRound)[:zb0013]
+ } else if (*z).CertRound != nil && cap((*z).CertRound) >= zb0016 {
+ (*z).CertRound = ((*z).CertRound)[:zb0016]
} else {
- (*z).CertRound = make([]basics.Round, zb0013)
+ (*z).CertRound = make([]basics.Round, zb0016)
}
for zb0001 := range (*z).CertRound {
bts, err = (*z).CertRound[zb0001].UnmarshalMsg(bts)
@@ -7655,48 +7991,48 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0015 []byte
- var zb0016 int
- zb0016, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0018 []byte
+ var zb0019 int
+ zb0019, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- if zb0016 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0016), uint64(maxBitmaskSize))
+ if zb0019 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0019), uint64(maxBitmaskSize))
return
}
- zb0015, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertRound))
+ zb0018, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- (*z).BitmaskCertRound = bitmask(zb0015)
+ (*z).BitmaskCertRound = bitmask(zb0018)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0017 int
- var zb0018 bool
- zb0017, zb0018, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0020 int
+ var zb0021 bool
+ zb0020, zb0021, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0017 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0017), uint64(maxEncodedTransactionGroups))
+ if zb0020 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0020), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0018 {
+ if zb0021 {
(*z).CertType = nil
- } else if (*z).CertType != nil && cap((*z).CertType) >= zb0017 {
- (*z).CertType = ((*z).CertType)[:zb0017]
+ } else if (*z).CertType != nil && cap((*z).CertType) >= zb0020 {
+ (*z).CertType = ((*z).CertType)[:zb0020]
} else {
- (*z).CertType = make([]protocol.CompactCertType, zb0017)
+ (*z).CertType = make([]protocol.CompactCertType, zb0020)
}
for zb0002 := range (*z).CertType {
bts, err = (*z).CertType[zb0002].UnmarshalMsg(bts)
@@ -7706,344 +8042,457 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0019 []byte
- var zb0020 int
- zb0020, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0022 []byte
+ var zb0023 int
+ zb0023, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- if zb0020 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0020), uint64(maxBitmaskSize))
+ if zb0023 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0023), uint64(maxBitmaskSize))
return
}
- zb0019, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertType))
+ zb0022, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- (*z).BitmaskCertType = bitmask(zb0019)
+ (*z).BitmaskCertType = bitmask(zb0022)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0021 int
- zb0021, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0024 int
+ var zb0025 bool
+ zb0024, zb0025, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
- if zb0021 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0021), uint64(maxAddressBytes))
- return
- }
- (*z).encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedCert.SigCommit)
- if err != nil {
+ if zb0024 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0024), uint64(maxAddressBytes))
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
+ if zb0025 {
+ (*z).encodedCert.SigCommit = nil
+ } else if (*z).encodedCert.SigCommit != nil && cap((*z).encodedCert.SigCommit) >= zb0024 {
+ (*z).encodedCert.SigCommit = ((*z).encodedCert.SigCommit)[:zb0024]
+ } else {
+ (*z).encodedCert.SigCommit = make([]crypto.GenericDigest, zb0024)
+ }
+ for zb0003 := range (*z).encodedCert.SigCommit {
+ bts, err = (*z).encodedCert.SigCommit[zb0003].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigCommit", zb0003)
+ return
+ }
+ }
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0022 []byte
- var zb0023 int
- zb0023, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0026 []byte
+ var zb0027 int
+ zb0027, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- if zb0023 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0023), uint64(maxBitmaskSize))
+ if zb0027 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0027), uint64(maxBitmaskSize))
return
}
- zb0022, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigCommit))
+ zb0026, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- (*z).encodedCert.BitmaskSigCommit = bitmask(zb0022)
+ (*z).encodedCert.BitmaskSigCommit = bitmask(zb0026)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0024 int
- var zb0025 bool
- zb0024, zb0025, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0028 int
+ var zb0029 bool
+ zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0024 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0024), uint64(maxEncodedTransactionGroups))
+ if zb0028 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0028), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0025 {
+ if zb0029 {
(*z).encodedCert.SignedWeight = nil
- } else if (*z).encodedCert.SignedWeight != nil && cap((*z).encodedCert.SignedWeight) >= zb0024 {
- (*z).encodedCert.SignedWeight = ((*z).encodedCert.SignedWeight)[:zb0024]
+ } else if (*z).encodedCert.SignedWeight != nil && cap((*z).encodedCert.SignedWeight) >= zb0028 {
+ (*z).encodedCert.SignedWeight = ((*z).encodedCert.SignedWeight)[:zb0028]
} else {
- (*z).encodedCert.SignedWeight = make([]uint64, zb0024)
+ (*z).encodedCert.SignedWeight = make([]uint64, zb0028)
}
- for zb0003 := range (*z).encodedCert.SignedWeight {
- (*z).encodedCert.SignedWeight[zb0003], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0004 := range (*z).encodedCert.SignedWeight {
+ (*z).encodedCert.SignedWeight[zb0004], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0003)
+ err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0004)
return
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0026 []byte
- var zb0027 int
- zb0027, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0030 []byte
+ var zb0031 int
+ zb0031, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- if zb0027 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0027), uint64(maxBitmaskSize))
+ if zb0031 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0031), uint64(maxBitmaskSize))
return
}
- zb0026, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSignedWeight))
+ zb0030, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- (*z).encodedCert.BitmaskSignedWeight = bitmask(zb0026)
+ (*z).encodedCert.BitmaskSignedWeight = bitmask(zb0030)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0028 int
- var zb0029 bool
- zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0032 int
+ var zb0033 bool
+ zb0032, zb0033, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0028 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0028), uint64(maxEncodedTransactionGroups))
+ if zb0032 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0032), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0029 {
+ if zb0033 {
(*z).encodedCert.SigProofs = nil
- } else if (*z).encodedCert.SigProofs != nil && cap((*z).encodedCert.SigProofs) >= zb0028 {
- (*z).encodedCert.SigProofs = ((*z).encodedCert.SigProofs)[:zb0028]
+ } else if (*z).encodedCert.SigProofs != nil && cap((*z).encodedCert.SigProofs) >= zb0032 {
+ (*z).encodedCert.SigProofs = ((*z).encodedCert.SigProofs)[:zb0032]
} else {
- (*z).encodedCert.SigProofs = make([]certProofs, zb0028)
+ (*z).encodedCert.SigProofs = make([]certProofs, zb0032)
}
- for zb0004 := range (*z).encodedCert.SigProofs {
- var zb0030 int
- var zb0031 bool
- zb0030, zb0031, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0005 := range (*z).encodedCert.SigProofs {
+ var zb0034 int
+ var zb0035 bool
+ zb0034, zb0035, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0004)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0005)
return
}
- if zb0030 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0030), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0004)
+ if zb0034 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0034), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0005)
return
}
- if zb0031 {
- (*z).encodedCert.SigProofs[zb0004] = nil
- } else if (*z).encodedCert.SigProofs[zb0004] != nil && cap((*z).encodedCert.SigProofs[zb0004]) >= zb0030 {
- (*z).encodedCert.SigProofs[zb0004] = ((*z).encodedCert.SigProofs[zb0004])[:zb0030]
+ if zb0035 {
+ (*z).encodedCert.SigProofs[zb0005] = nil
+ } else if (*z).encodedCert.SigProofs[zb0005] != nil && cap((*z).encodedCert.SigProofs[zb0005]) >= zb0034 {
+ (*z).encodedCert.SigProofs[zb0005] = ((*z).encodedCert.SigProofs[zb0005])[:zb0034]
} else {
- (*z).encodedCert.SigProofs[zb0004] = make(certProofs, zb0030)
+ (*z).encodedCert.SigProofs[zb0005] = make(certProofs, zb0034)
}
- for zb0005 := range (*z).encodedCert.SigProofs[zb0004] {
- bts, err = (*z).encodedCert.SigProofs[zb0004][zb0005].UnmarshalMsg(bts)
+ for zb0006 := range (*z).encodedCert.SigProofs[zb0005] {
+ bts, err = (*z).encodedCert.SigProofs[zb0005][zb0006].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0004, zb0005)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0005, zb0006)
return
}
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0032 []byte
- var zb0033 int
- zb0033, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0036 []byte
+ var zb0037 int
+ zb0037, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- if zb0033 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0033), uint64(maxBitmaskSize))
+ if zb0037 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0037), uint64(maxBitmaskSize))
return
}
- zb0032, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigProofs))
+ zb0036, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- (*z).encodedCert.BitmaskSigProofs = bitmask(zb0032)
+ (*z).encodedCert.BitmaskSigProofs = bitmask(zb0036)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0034 int
- var zb0035 bool
- zb0034, zb0035, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0038 int
+ var zb0039 bool
+ zb0038, zb0039, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0038 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0038), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0039 {
+ (*z).encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedCert.SigProofHashTypes != nil && cap((*z).encodedCert.SigProofHashTypes) >= zb0038 {
+ (*z).encodedCert.SigProofHashTypes = ((*z).encodedCert.SigProofHashTypes)[:zb0038]
+ } else {
+ (*z).encodedCert.SigProofHashTypes = make([]uint64, zb0038)
+ }
+ for zb0007 := range (*z).encodedCert.SigProofHashTypes {
+ (*z).encodedCert.SigProofHashTypes[zb0007], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes", zb0007)
+ return
+ }
+ }
+ }
+ if zb0014 > 0 {
+ zb0014--
+ {
+ var zb0040 []byte
+ var zb0041 int
+ zb0041, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ if zb0041 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0041), uint64(maxBitmaskSize))
+ return
+ }
+ zb0040, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedCert.BitmaskSigsHash = bitmask(zb0040)
+ }
+ }
+ if zb0014 > 0 {
+ zb0014--
+ var zb0042 int
+ var zb0043 bool
+ zb0042, zb0043, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0034 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0034), uint64(maxEncodedTransactionGroups))
+ if zb0042 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0042), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0035 {
+ if zb0043 {
(*z).encodedCert.PartProofs = nil
- } else if (*z).encodedCert.PartProofs != nil && cap((*z).encodedCert.PartProofs) >= zb0034 {
- (*z).encodedCert.PartProofs = ((*z).encodedCert.PartProofs)[:zb0034]
+ } else if (*z).encodedCert.PartProofs != nil && cap((*z).encodedCert.PartProofs) >= zb0042 {
+ (*z).encodedCert.PartProofs = ((*z).encodedCert.PartProofs)[:zb0042]
} else {
- (*z).encodedCert.PartProofs = make([]certProofs, zb0034)
+ (*z).encodedCert.PartProofs = make([]certProofs, zb0042)
}
- for zb0006 := range (*z).encodedCert.PartProofs {
- var zb0036 int
- var zb0037 bool
- zb0036, zb0037, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0008 := range (*z).encodedCert.PartProofs {
+ var zb0044 int
+ var zb0045 bool
+ zb0044, zb0045, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0008)
return
}
- if zb0036 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0036), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006)
+ if zb0044 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0044), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0008)
return
}
- if zb0037 {
- (*z).encodedCert.PartProofs[zb0006] = nil
- } else if (*z).encodedCert.PartProofs[zb0006] != nil && cap((*z).encodedCert.PartProofs[zb0006]) >= zb0036 {
- (*z).encodedCert.PartProofs[zb0006] = ((*z).encodedCert.PartProofs[zb0006])[:zb0036]
+ if zb0045 {
+ (*z).encodedCert.PartProofs[zb0008] = nil
+ } else if (*z).encodedCert.PartProofs[zb0008] != nil && cap((*z).encodedCert.PartProofs[zb0008]) >= zb0044 {
+ (*z).encodedCert.PartProofs[zb0008] = ((*z).encodedCert.PartProofs[zb0008])[:zb0044]
} else {
- (*z).encodedCert.PartProofs[zb0006] = make(certProofs, zb0036)
+ (*z).encodedCert.PartProofs[zb0008] = make(certProofs, zb0044)
}
- for zb0007 := range (*z).encodedCert.PartProofs[zb0006] {
- bts, err = (*z).encodedCert.PartProofs[zb0006][zb0007].UnmarshalMsg(bts)
+ for zb0009 := range (*z).encodedCert.PartProofs[zb0008] {
+ bts, err = (*z).encodedCert.PartProofs[zb0008][zb0009].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0006, zb0007)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0008, zb0009)
return
}
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0038 []byte
- var zb0039 int
- zb0039, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0046 []byte
+ var zb0047 int
+ zb0047, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- if zb0039 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0039), uint64(maxBitmaskSize))
+ if zb0047 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0047), uint64(maxBitmaskSize))
return
}
- zb0038, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartProofs))
+ zb0046, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- (*z).encodedCert.BitmaskPartProofs = bitmask(zb0038)
+ (*z).encodedCert.BitmaskPartProofs = bitmask(zb0046)
+ }
+ }
+ if zb0014 > 0 {
+ zb0014--
+ var zb0048 int
+ var zb0049 bool
+ zb0048, zb0049, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0048 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0048), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0049 {
+ (*z).encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedCert.PartProofHashTypes != nil && cap((*z).encodedCert.PartProofHashTypes) >= zb0048 {
+ (*z).encodedCert.PartProofHashTypes = ((*z).encodedCert.PartProofHashTypes)[:zb0048]
+ } else {
+ (*z).encodedCert.PartProofHashTypes = make([]uint64, zb0048)
+ }
+ for zb0010 := range (*z).encodedCert.PartProofHashTypes {
+ (*z).encodedCert.PartProofHashTypes[zb0010], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes", zb0010)
+ return
+ }
+ }
+ }
+ if zb0014 > 0 {
+ zb0014--
+ {
+ var zb0050 []byte
+ var zb0051 int
+ zb0051, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ if zb0051 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0051), uint64(maxBitmaskSize))
+ return
+ }
+ zb0050, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ (*z).encodedCert.BitmaskPartHash = bitmask(zb0050)
}
}
- if zb0011 > 0 {
- zb0011--
- var zb0040 int
- var zb0041 bool
- zb0040, zb0041, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0014 > 0 {
+ zb0014--
+ var zb0052 int
+ var zb0053 bool
+ zb0052, zb0053, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0040 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0040), uint64(maxEncodedTransactionGroups))
+ if zb0052 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0052), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0041 {
+ if zb0053 {
(*z).encodedCert.Reveals = nil
- } else if (*z).encodedCert.Reveals != nil && cap((*z).encodedCert.Reveals) >= zb0040 {
- (*z).encodedCert.Reveals = ((*z).encodedCert.Reveals)[:zb0040]
+ } else if (*z).encodedCert.Reveals != nil && cap((*z).encodedCert.Reveals) >= zb0052 {
+ (*z).encodedCert.Reveals = ((*z).encodedCert.Reveals)[:zb0052]
} else {
- (*z).encodedCert.Reveals = make([]revealMap, zb0040)
+ (*z).encodedCert.Reveals = make([]revealMap, zb0052)
}
- for zb0008 := range (*z).encodedCert.Reveals {
- var zb0042 int
- var zb0043 bool
- zb0042, zb0043, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0011 := range (*z).encodedCert.Reveals {
+ var zb0054 int
+ var zb0055 bool
+ zb0054, zb0055, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0008)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0011)
return
}
- if zb0042 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0042), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0008)
+ if zb0054 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0054), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0011)
return
}
- if zb0043 {
- (*z).encodedCert.Reveals[zb0008] = nil
- } else if (*z).encodedCert.Reveals[zb0008] == nil {
- (*z).encodedCert.Reveals[zb0008] = make(revealMap, zb0042)
+ if zb0055 {
+ (*z).encodedCert.Reveals[zb0011] = nil
+ } else if (*z).encodedCert.Reveals[zb0011] == nil {
+ (*z).encodedCert.Reveals[zb0011] = make(revealMap, zb0054)
}
- for zb0042 > 0 {
- var zb0009 uint64
- var zb0010 compactcert.Reveal
- zb0042--
- zb0009, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0054 > 0 {
+ var zb0012 uint64
+ var zb0013 compactcert.Reveal
+ zb0054--
+ zb0012, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0008)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0011)
return
}
- bts, err = zb0010.UnmarshalMsg(bts)
+ bts, err = zb0013.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0008, zb0009)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0011, zb0012)
return
}
- (*z).encodedCert.Reveals[zb0008][zb0009] = zb0010
+ (*z).encodedCert.Reveals[zb0011][zb0012] = zb0013
}
}
}
- if zb0011 > 0 {
- zb0011--
+ if zb0014 > 0 {
+ zb0014--
{
- var zb0044 []byte
- var zb0045 int
- zb0045, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0056 []byte
+ var zb0057 int
+ zb0057, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- if zb0045 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0045), uint64(maxBitmaskSize))
+ if zb0057 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0057), uint64(maxBitmaskSize))
return
}
- zb0044, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskReveals))
+ zb0056, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- (*z).encodedCert.BitmaskReveals = bitmask(zb0044)
+ (*z).encodedCert.BitmaskReveals = bitmask(zb0056)
}
}
- if zb0011 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0011)
+ if zb0014 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0014)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -8054,11 +8503,11 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
err = msgp.WrapError(err)
return
}
- if zb0012 {
+ if zb0015 {
(*z) = encodedCompactCertTxnFields{}
}
- for zb0011 > 0 {
- zb0011--
+ for zb0014 > 0 {
+ zb0014--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -8066,24 +8515,24 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
}
switch string(field) {
case "certrnd":
- var zb0046 int
- var zb0047 bool
- zb0046, zb0047, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0058 int
+ var zb0059 bool
+ zb0058, zb0059, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0046 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0046), uint64(maxEncodedTransactionGroups))
+ if zb0058 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0058), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0047 {
+ if zb0059 {
(*z).CertRound = nil
- } else if (*z).CertRound != nil && cap((*z).CertRound) >= zb0046 {
- (*z).CertRound = ((*z).CertRound)[:zb0046]
+ } else if (*z).CertRound != nil && cap((*z).CertRound) >= zb0058 {
+ (*z).CertRound = ((*z).CertRound)[:zb0058]
} else {
- (*z).CertRound = make([]basics.Round, zb0046)
+ (*z).CertRound = make([]basics.Round, zb0058)
}
for zb0001 := range (*z).CertRound {
bts, err = (*z).CertRound[zb0001].UnmarshalMsg(bts)
@@ -8094,43 +8543,43 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
}
case "certrndbm":
{
- var zb0048 []byte
- var zb0049 int
- zb0049, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0060 []byte
+ var zb0061 int
+ zb0061, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- if zb0049 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0049), uint64(maxBitmaskSize))
+ if zb0061 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0061), uint64(maxBitmaskSize))
return
}
- zb0048, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertRound))
+ zb0060, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- (*z).BitmaskCertRound = bitmask(zb0048)
+ (*z).BitmaskCertRound = bitmask(zb0060)
}
case "certtype":
- var zb0050 int
- var zb0051 bool
- zb0050, zb0051, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0062 int
+ var zb0063 bool
+ zb0062, zb0063, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertType")
return
}
- if zb0050 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0050), uint64(maxEncodedTransactionGroups))
+ if zb0062 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0062), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertType")
return
}
- if zb0051 {
+ if zb0063 {
(*z).CertType = nil
- } else if (*z).CertType != nil && cap((*z).CertType) >= zb0050 {
- (*z).CertType = ((*z).CertType)[:zb0050]
+ } else if (*z).CertType != nil && cap((*z).CertType) >= zb0062 {
+ (*z).CertType = ((*z).CertType)[:zb0062]
} else {
- (*z).CertType = make([]protocol.CompactCertType, zb0050)
+ (*z).CertType = make([]protocol.CompactCertType, zb0062)
}
for zb0002 := range (*z).CertType {
bts, err = (*z).CertType[zb0002].UnmarshalMsg(bts)
@@ -8141,317 +8590,422 @@ func (z *encodedCompactCertTxnFields) UnmarshalMsg(bts []byte) (o []byte, err er
}
case "certtypebm":
{
- var zb0052 []byte
- var zb0053 int
- zb0053, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0064 []byte
+ var zb0065 int
+ zb0065, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- if zb0053 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0053), uint64(maxBitmaskSize))
+ if zb0065 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0065), uint64(maxBitmaskSize))
return
}
- zb0052, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertType))
+ zb0064, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- (*z).BitmaskCertType = bitmask(zb0052)
+ (*z).BitmaskCertType = bitmask(zb0064)
}
case "certc":
- var zb0054 int
- zb0054, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0066 int
+ var zb0067 bool
+ zb0066, zb0067, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigCommit")
return
}
- if zb0054 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0054), uint64(maxAddressBytes))
- return
- }
- (*z).encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedCert.SigCommit)
- if err != nil {
+ if zb0066 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0066), uint64(maxAddressBytes))
err = msgp.WrapError(err, "SigCommit")
return
}
+ if zb0067 {
+ (*z).encodedCert.SigCommit = nil
+ } else if (*z).encodedCert.SigCommit != nil && cap((*z).encodedCert.SigCommit) >= zb0066 {
+ (*z).encodedCert.SigCommit = ((*z).encodedCert.SigCommit)[:zb0066]
+ } else {
+ (*z).encodedCert.SigCommit = make([]crypto.GenericDigest, zb0066)
+ }
+ for zb0003 := range (*z).encodedCert.SigCommit {
+ bts, err = (*z).encodedCert.SigCommit[zb0003].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigCommit", zb0003)
+ return
+ }
+ }
case "certcbm":
{
- var zb0055 []byte
- var zb0056 int
- zb0056, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0068 []byte
+ var zb0069 int
+ zb0069, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- if zb0056 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0056), uint64(maxBitmaskSize))
+ if zb0069 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0069), uint64(maxBitmaskSize))
return
}
- zb0055, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigCommit))
+ zb0068, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- (*z).encodedCert.BitmaskSigCommit = bitmask(zb0055)
+ (*z).encodedCert.BitmaskSigCommit = bitmask(zb0068)
}
case "certw":
- var zb0057 int
- var zb0058 bool
- zb0057, zb0058, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0070 int
+ var zb0071 bool
+ zb0070, zb0071, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0057 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0057), uint64(maxEncodedTransactionGroups))
+ if zb0070 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0070), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0058 {
+ if zb0071 {
(*z).encodedCert.SignedWeight = nil
- } else if (*z).encodedCert.SignedWeight != nil && cap((*z).encodedCert.SignedWeight) >= zb0057 {
- (*z).encodedCert.SignedWeight = ((*z).encodedCert.SignedWeight)[:zb0057]
+ } else if (*z).encodedCert.SignedWeight != nil && cap((*z).encodedCert.SignedWeight) >= zb0070 {
+ (*z).encodedCert.SignedWeight = ((*z).encodedCert.SignedWeight)[:zb0070]
} else {
- (*z).encodedCert.SignedWeight = make([]uint64, zb0057)
+ (*z).encodedCert.SignedWeight = make([]uint64, zb0070)
}
- for zb0003 := range (*z).encodedCert.SignedWeight {
- (*z).encodedCert.SignedWeight[zb0003], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0004 := range (*z).encodedCert.SignedWeight {
+ (*z).encodedCert.SignedWeight[zb0004], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SignedWeight", zb0003)
+ err = msgp.WrapError(err, "SignedWeight", zb0004)
return
}
}
case "certwbm":
{
- var zb0059 []byte
- var zb0060 int
- zb0060, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0072 []byte
+ var zb0073 int
+ zb0073, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- if zb0060 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0060), uint64(maxBitmaskSize))
+ if zb0073 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0073), uint64(maxBitmaskSize))
return
}
- zb0059, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSignedWeight))
+ zb0072, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- (*z).encodedCert.BitmaskSignedWeight = bitmask(zb0059)
+ (*z).encodedCert.BitmaskSignedWeight = bitmask(zb0072)
}
case "certS":
- var zb0061 int
- var zb0062 bool
- zb0061, zb0062, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0074 int
+ var zb0075 bool
+ zb0074, zb0075, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0061 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0061), uint64(maxEncodedTransactionGroups))
+ if zb0074 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0074), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0062 {
+ if zb0075 {
(*z).encodedCert.SigProofs = nil
- } else if (*z).encodedCert.SigProofs != nil && cap((*z).encodedCert.SigProofs) >= zb0061 {
- (*z).encodedCert.SigProofs = ((*z).encodedCert.SigProofs)[:zb0061]
+ } else if (*z).encodedCert.SigProofs != nil && cap((*z).encodedCert.SigProofs) >= zb0074 {
+ (*z).encodedCert.SigProofs = ((*z).encodedCert.SigProofs)[:zb0074]
} else {
- (*z).encodedCert.SigProofs = make([]certProofs, zb0061)
+ (*z).encodedCert.SigProofs = make([]certProofs, zb0074)
}
- for zb0004 := range (*z).encodedCert.SigProofs {
- var zb0063 int
- var zb0064 bool
- zb0063, zb0064, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0005 := range (*z).encodedCert.SigProofs {
+ var zb0076 int
+ var zb0077 bool
+ zb0076, zb0077, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0004)
+ err = msgp.WrapError(err, "SigProofs", zb0005)
return
}
- if zb0063 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0063), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs", zb0004)
+ if zb0076 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0076), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "SigProofs", zb0005)
return
}
- if zb0064 {
- (*z).encodedCert.SigProofs[zb0004] = nil
- } else if (*z).encodedCert.SigProofs[zb0004] != nil && cap((*z).encodedCert.SigProofs[zb0004]) >= zb0063 {
- (*z).encodedCert.SigProofs[zb0004] = ((*z).encodedCert.SigProofs[zb0004])[:zb0063]
+ if zb0077 {
+ (*z).encodedCert.SigProofs[zb0005] = nil
+ } else if (*z).encodedCert.SigProofs[zb0005] != nil && cap((*z).encodedCert.SigProofs[zb0005]) >= zb0076 {
+ (*z).encodedCert.SigProofs[zb0005] = ((*z).encodedCert.SigProofs[zb0005])[:zb0076]
} else {
- (*z).encodedCert.SigProofs[zb0004] = make(certProofs, zb0063)
+ (*z).encodedCert.SigProofs[zb0005] = make(certProofs, zb0076)
}
- for zb0005 := range (*z).encodedCert.SigProofs[zb0004] {
- bts, err = (*z).encodedCert.SigProofs[zb0004][zb0005].UnmarshalMsg(bts)
+ for zb0006 := range (*z).encodedCert.SigProofs[zb0005] {
+ bts, err = (*z).encodedCert.SigProofs[zb0005][zb0006].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0004, zb0005)
+ err = msgp.WrapError(err, "SigProofs", zb0005, zb0006)
return
}
}
}
case "certSbm":
{
- var zb0065 []byte
- var zb0066 int
- zb0066, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0078 []byte
+ var zb0079 int
+ zb0079, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- if zb0066 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0066), uint64(maxBitmaskSize))
+ if zb0079 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0079), uint64(maxBitmaskSize))
return
}
- zb0065, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigProofs))
+ zb0078, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- (*z).encodedCert.BitmaskSigProofs = bitmask(zb0065)
+ (*z).encodedCert.BitmaskSigProofs = bitmask(zb0078)
+ }
+ case "certSH":
+ var zb0080 int
+ var zb0081 bool
+ zb0080, zb0081, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0080 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0080), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0081 {
+ (*z).encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedCert.SigProofHashTypes != nil && cap((*z).encodedCert.SigProofHashTypes) >= zb0080 {
+ (*z).encodedCert.SigProofHashTypes = ((*z).encodedCert.SigProofHashTypes)[:zb0080]
+ } else {
+ (*z).encodedCert.SigProofHashTypes = make([]uint64, zb0080)
+ }
+ for zb0007 := range (*z).encodedCert.SigProofHashTypes {
+ (*z).encodedCert.SigProofHashTypes[zb0007], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes", zb0007)
+ return
+ }
+ }
+ case "certSHbm":
+ {
+ var zb0082 []byte
+ var zb0083 int
+ zb0083, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ if zb0083 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0083), uint64(maxBitmaskSize))
+ return
+ }
+ zb0082, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedCert.BitmaskSigsHash = bitmask(zb0082)
}
case "certP":
- var zb0067 int
- var zb0068 bool
- zb0067, zb0068, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0084 int
+ var zb0085 bool
+ zb0084, zb0085, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0067 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0067), uint64(maxEncodedTransactionGroups))
+ if zb0084 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0084), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0068 {
+ if zb0085 {
(*z).encodedCert.PartProofs = nil
- } else if (*z).encodedCert.PartProofs != nil && cap((*z).encodedCert.PartProofs) >= zb0067 {
- (*z).encodedCert.PartProofs = ((*z).encodedCert.PartProofs)[:zb0067]
+ } else if (*z).encodedCert.PartProofs != nil && cap((*z).encodedCert.PartProofs) >= zb0084 {
+ (*z).encodedCert.PartProofs = ((*z).encodedCert.PartProofs)[:zb0084]
} else {
- (*z).encodedCert.PartProofs = make([]certProofs, zb0067)
+ (*z).encodedCert.PartProofs = make([]certProofs, zb0084)
}
- for zb0006 := range (*z).encodedCert.PartProofs {
- var zb0069 int
- var zb0070 bool
- zb0069, zb0070, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0008 := range (*z).encodedCert.PartProofs {
+ var zb0086 int
+ var zb0087 bool
+ zb0086, zb0087, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0006)
+ err = msgp.WrapError(err, "PartProofs", zb0008)
return
}
- if zb0069 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0069), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs", zb0006)
+ if zb0086 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0086), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "PartProofs", zb0008)
return
}
- if zb0070 {
- (*z).encodedCert.PartProofs[zb0006] = nil
- } else if (*z).encodedCert.PartProofs[zb0006] != nil && cap((*z).encodedCert.PartProofs[zb0006]) >= zb0069 {
- (*z).encodedCert.PartProofs[zb0006] = ((*z).encodedCert.PartProofs[zb0006])[:zb0069]
+ if zb0087 {
+ (*z).encodedCert.PartProofs[zb0008] = nil
+ } else if (*z).encodedCert.PartProofs[zb0008] != nil && cap((*z).encodedCert.PartProofs[zb0008]) >= zb0086 {
+ (*z).encodedCert.PartProofs[zb0008] = ((*z).encodedCert.PartProofs[zb0008])[:zb0086]
} else {
- (*z).encodedCert.PartProofs[zb0006] = make(certProofs, zb0069)
+ (*z).encodedCert.PartProofs[zb0008] = make(certProofs, zb0086)
}
- for zb0007 := range (*z).encodedCert.PartProofs[zb0006] {
- bts, err = (*z).encodedCert.PartProofs[zb0006][zb0007].UnmarshalMsg(bts)
+ for zb0009 := range (*z).encodedCert.PartProofs[zb0008] {
+ bts, err = (*z).encodedCert.PartProofs[zb0008][zb0009].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0006, zb0007)
+ err = msgp.WrapError(err, "PartProofs", zb0008, zb0009)
return
}
}
}
case "certPbm":
{
- var zb0071 []byte
- var zb0072 int
- zb0072, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0088 []byte
+ var zb0089 int
+ zb0089, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- if zb0072 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0072), uint64(maxBitmaskSize))
+ if zb0089 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0089), uint64(maxBitmaskSize))
return
}
- zb0071, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartProofs))
+ zb0088, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- (*z).encodedCert.BitmaskPartProofs = bitmask(zb0071)
+ (*z).encodedCert.BitmaskPartProofs = bitmask(zb0088)
+ }
+ case "certPH":
+ var zb0090 int
+ var zb0091 bool
+ zb0090, zb0091, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0090 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0090), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0091 {
+ (*z).encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedCert.PartProofHashTypes != nil && cap((*z).encodedCert.PartProofHashTypes) >= zb0090 {
+ (*z).encodedCert.PartProofHashTypes = ((*z).encodedCert.PartProofHashTypes)[:zb0090]
+ } else {
+ (*z).encodedCert.PartProofHashTypes = make([]uint64, zb0090)
+ }
+ for zb0010 := range (*z).encodedCert.PartProofHashTypes {
+ (*z).encodedCert.PartProofHashTypes[zb0010], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes", zb0010)
+ return
+ }
+ }
+ case "certPHbm":
+ {
+ var zb0092 []byte
+ var zb0093 int
+ zb0093, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ if zb0093 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0093), uint64(maxBitmaskSize))
+ return
+ }
+ zb0092, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ (*z).encodedCert.BitmaskPartHash = bitmask(zb0092)
}
case "certr":
- var zb0073 int
- var zb0074 bool
- zb0073, zb0074, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0094 int
+ var zb0095 bool
+ zb0094, zb0095, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0073 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0073), uint64(maxEncodedTransactionGroups))
+ if zb0094 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0094), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0074 {
+ if zb0095 {
(*z).encodedCert.Reveals = nil
- } else if (*z).encodedCert.Reveals != nil && cap((*z).encodedCert.Reveals) >= zb0073 {
- (*z).encodedCert.Reveals = ((*z).encodedCert.Reveals)[:zb0073]
+ } else if (*z).encodedCert.Reveals != nil && cap((*z).encodedCert.Reveals) >= zb0094 {
+ (*z).encodedCert.Reveals = ((*z).encodedCert.Reveals)[:zb0094]
} else {
- (*z).encodedCert.Reveals = make([]revealMap, zb0073)
+ (*z).encodedCert.Reveals = make([]revealMap, zb0094)
}
- for zb0008 := range (*z).encodedCert.Reveals {
- var zb0075 int
- var zb0076 bool
- zb0075, zb0076, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0011 := range (*z).encodedCert.Reveals {
+ var zb0096 int
+ var zb0097 bool
+ zb0096, zb0097, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0008)
+ err = msgp.WrapError(err, "Reveals", zb0011)
return
}
- if zb0075 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0075), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "Reveals", zb0008)
+ if zb0096 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0096), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "Reveals", zb0011)
return
}
- if zb0076 {
- (*z).encodedCert.Reveals[zb0008] = nil
- } else if (*z).encodedCert.Reveals[zb0008] == nil {
- (*z).encodedCert.Reveals[zb0008] = make(revealMap, zb0075)
+ if zb0097 {
+ (*z).encodedCert.Reveals[zb0011] = nil
+ } else if (*z).encodedCert.Reveals[zb0011] == nil {
+ (*z).encodedCert.Reveals[zb0011] = make(revealMap, zb0096)
}
- for zb0075 > 0 {
- var zb0009 uint64
- var zb0010 compactcert.Reveal
- zb0075--
- zb0009, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0096 > 0 {
+ var zb0012 uint64
+ var zb0013 compactcert.Reveal
+ zb0096--
+ zb0012, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0008)
+ err = msgp.WrapError(err, "Reveals", zb0011)
return
}
- bts, err = zb0010.UnmarshalMsg(bts)
+ bts, err = zb0013.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0008, zb0009)
+ err = msgp.WrapError(err, "Reveals", zb0011, zb0012)
return
}
- (*z).encodedCert.Reveals[zb0008][zb0009] = zb0010
+ (*z).encodedCert.Reveals[zb0011][zb0012] = zb0013
}
}
case "certrbm":
{
- var zb0077 []byte
- var zb0078 int
- zb0078, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0098 []byte
+ var zb0099 int
+ zb0099, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- if zb0078 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0078), uint64(maxBitmaskSize))
+ if zb0099 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0099), uint64(maxBitmaskSize))
return
}
- zb0077, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskReveals))
+ zb0098, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- (*z).encodedCert.BitmaskReveals = bitmask(zb0077)
+ (*z).encodedCert.BitmaskReveals = bitmask(zb0098)
}
default:
err = msgp.ErrNoField(string(field))
@@ -8473,7 +9027,7 @@ func (_ *encodedCompactCertTxnFields) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *encodedCompactCertTxnFields) Msgsize() (s int) {
- s = 1 + 8 + msgp.ArrayHeaderSize
+ s = 3 + 8 + msgp.ArrayHeaderSize
for zb0001 := range (*z).CertRound {
s += (*z).CertRound[zb0001].Msgsize()
}
@@ -8481,28 +9035,32 @@ func (z *encodedCompactCertTxnFields) Msgsize() (s int) {
for zb0002 := range (*z).CertType {
s += (*z).CertType[zb0002].Msgsize()
}
- s += 11 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskCertType)) + 6 + msgp.BytesPrefixSize + len((*z).encodedCert.SigCommit) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
- for zb0004 := range (*z).encodedCert.SigProofs {
+ s += 11 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskCertType)) + 6 + msgp.ArrayHeaderSize
+ for zb0003 := range (*z).encodedCert.SigCommit {
+ s += (*z).encodedCert.SigCommit[zb0003].Msgsize()
+ }
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
+ for zb0005 := range (*z).encodedCert.SigProofs {
s += msgp.ArrayHeaderSize
- for zb0005 := range (*z).encodedCert.SigProofs[zb0004] {
- s += (*z).encodedCert.SigProofs[zb0004][zb0005].Msgsize()
+ for zb0006 := range (*z).encodedCert.SigProofs[zb0005] {
+ s += (*z).encodedCert.SigProofs[zb0005][zb0006].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSigProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0006 := range (*z).encodedCert.PartProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSigProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedCert.SigProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskSigsHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0008 := range (*z).encodedCert.PartProofs {
s += msgp.ArrayHeaderSize
- for zb0007 := range (*z).encodedCert.PartProofs[zb0006] {
- s += (*z).encodedCert.PartProofs[zb0006][zb0007].Msgsize()
+ for zb0009 := range (*z).encodedCert.PartProofs[zb0008] {
+ s += (*z).encodedCert.PartProofs[zb0008][zb0009].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskPartProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0008 := range (*z).encodedCert.Reveals {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskPartProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedCert.PartProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedCert.BitmaskPartHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0011 := range (*z).encodedCert.Reveals {
s += msgp.MapHeaderSize
- if (*z).encodedCert.Reveals[zb0008] != nil {
- for zb0009, zb0010 := range (*z).encodedCert.Reveals[zb0008] {
- _ = zb0009
- _ = zb0010
- s += 0 + msgp.Uint64Size + zb0010.Msgsize()
+ if (*z).encodedCert.Reveals[zb0011] != nil {
+ for zb0012, zb0013 := range (*z).encodedCert.Reveals[zb0011] {
+ _ = zb0012
+ _ = zb0013
+ s += 0 + msgp.Uint64Size + zb0013.Msgsize()
}
}
}
@@ -8512,65 +9070,90 @@ func (z *encodedCompactCertTxnFields) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *encodedCompactCertTxnFields) MsgIsZero() bool {
- return (len((*z).CertRound) == 0) && (len((*z).BitmaskCertRound) == 0) && (len((*z).CertType) == 0) && (len((*z).BitmaskCertType) == 0) && (len((*z).encodedCert.SigCommit) == 0) && (len((*z).encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedCert.SignedWeight) == 0) && (len((*z).encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedCert.SigProofs) == 0) && (len((*z).encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedCert.PartProofs) == 0) && (len((*z).encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedCert.Reveals) == 0) && (len((*z).encodedCert.BitmaskReveals) == 0)
+ return (len((*z).CertRound) == 0) && (len((*z).BitmaskCertRound) == 0) && (len((*z).CertType) == 0) && (len((*z).BitmaskCertType) == 0) && (len((*z).encodedCert.SigCommit) == 0) && (len((*z).encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedCert.SignedWeight) == 0) && (len((*z).encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedCert.SigProofs) == 0) && (len((*z).encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedCert.SigProofHashTypes) == 0) && (len((*z).encodedCert.BitmaskSigsHash) == 0) && (len((*z).encodedCert.PartProofs) == 0) && (len((*z).encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedCert.PartProofHashTypes) == 0) && (len((*z).encodedCert.BitmaskPartHash) == 0) && (len((*z).encodedCert.Reveals) == 0) && (len((*z).encodedCert.BitmaskReveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
func (z *encodedKeyregTxnFields) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(9)
- var zb0004Mask uint16 /* 10 bits */
+ zb0005Len := uint32(11)
+ var zb0005Mask uint16 /* 12 bits */
+ if len((*z).CommitmentRoot) == 0 {
+ zb0005Len--
+ zb0005Mask |= 0x2
+ }
if len((*z).BitmaskNonparticipation) == 0 {
- zb0004Len--
- zb0004Mask |= 0x2
+ zb0005Len--
+ zb0005Mask |= 0x4
}
if len((*z).SelectionPK) == 0 {
- zb0004Len--
- zb0004Mask |= 0x4
+ zb0005Len--
+ zb0005Mask |= 0x8
+ }
+ if len((*z).HasValidRoot) == 0 {
+ zb0005Len--
+ zb0005Mask |= 0x10
}
if len((*z).VoteFirst) == 0 {
- zb0004Len--
- zb0004Mask |= 0x8
+ zb0005Len--
+ zb0005Mask |= 0x20
}
if len((*z).BitmaskVoteFirst) == 0 {
- zb0004Len--
- zb0004Mask |= 0x10
+ zb0005Len--
+ zb0005Mask |= 0x40
}
if len((*z).BitmaskKeys) == 0 {
- zb0004Len--
- zb0004Mask |= 0x20
+ zb0005Len--
+ zb0005Mask |= 0x80
}
if len((*z).VoteKeyDilution) == 0 {
- zb0004Len--
- zb0004Mask |= 0x40
+ zb0005Len--
+ zb0005Mask |= 0x100
}
if len((*z).VotePK) == 0 {
- zb0004Len--
- zb0004Mask |= 0x80
+ zb0005Len--
+ zb0005Mask |= 0x200
}
if len((*z).VoteLast) == 0 {
- zb0004Len--
- zb0004Mask |= 0x100
+ zb0005Len--
+ zb0005Mask |= 0x400
}
if len((*z).BitmaskVoteLast) == 0 {
- zb0004Len--
- zb0004Mask |= 0x200
+ zb0005Len--
+ zb0005Mask |= 0x800
}
- // variable map header, size zb0004Len
- o = append(o, 0x80|uint8(zb0004Len))
- if zb0004Len != 0 {
- if (zb0004Mask & 0x2) == 0 { // if not empty
+ // variable map header, size zb0005Len
+ o = append(o, 0x80|uint8(zb0005Len))
+ if zb0005Len != 0 {
+ if (zb0005Mask & 0x2) == 0 { // if not empty
+ // string "comt"
+ o = append(o, 0xa4, 0x63, 0x6f, 0x6d, 0x74)
+ o = msgp.AppendBytes(o, (*z).CommitmentRoot)
+ }
+ if (zb0005Mask & 0x4) == 0 { // if not empty
// string "nonpartbm"
o = append(o, 0xa9, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskNonparticipation))
}
- if (zb0004Mask & 0x4) == 0 { // if not empty
+ if (zb0005Mask & 0x8) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).SelectionPK)
}
- if (zb0004Mask & 0x8) == 0 { // if not empty
+ if (zb0005Mask & 0x10) == 0 { // if not empty
+ // string "vldrt"
+ o = append(o, 0xa5, 0x76, 0x6c, 0x64, 0x72, 0x74)
+ if (*z).HasValidRoot == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).HasValidRoot)))
+ }
+ for zb0004 := range (*z).HasValidRoot {
+ o = msgp.AppendBool(o, (*z).HasValidRoot[zb0004])
+ }
+ }
+ if (zb0005Mask & 0x20) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
if (*z).VoteFirst == nil {
@@ -8582,17 +9165,17 @@ func (z *encodedKeyregTxnFields) MarshalMsg(b []byte) (o []byte) {
o = (*z).VoteFirst[zb0001].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x10) == 0 { // if not empty
+ if (zb0005Mask & 0x40) == 0 { // if not empty
// string "votefstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskVoteFirst))
}
- if (zb0004Mask & 0x20) == 0 { // if not empty
+ if (zb0005Mask & 0x80) == 0 { // if not empty
// string "votekbm"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskKeys))
}
- if (zb0004Mask & 0x40) == 0 { // if not empty
+ if (zb0005Mask & 0x100) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
if (*z).VoteKeyDilution == nil {
@@ -8604,12 +9187,12 @@ func (z *encodedKeyregTxnFields) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).VoteKeyDilution[zb0003])
}
}
- if (zb0004Mask & 0x80) == 0 { // if not empty
+ if (zb0005Mask & 0x200) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).VotePK)
}
- if (zb0004Mask & 0x100) == 0 { // if not empty
+ if (zb0005Mask & 0x400) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
if (*z).VoteLast == nil {
@@ -8621,7 +9204,7 @@ func (z *encodedKeyregTxnFields) MarshalMsg(b []byte) (o []byte) {
o = (*z).VoteLast[zb0002].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0005Mask & 0x800) == 0 { // if not empty
// string "votelstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskVoteLast))
@@ -8639,25 +9222,25 @@ func (_ *encodedKeyregTxnFields) CanMarshalMsg(z interface{}) bool {
func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0004 int
- var zb0005 bool
- zb0004, zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0005 int
+ var zb0006 bool
+ zb0005, zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0005, zb0006, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0004 > 0 {
- zb0004--
- var zb0006 int
- zb0006, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0007 int
+ zb0007, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VotePK")
return
}
- if zb0006 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0006), uint64(maxAddressBytes))
+ if zb0007 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0007), uint64(maxAddressBytes))
return
}
(*z).VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).VotePK)
@@ -8666,16 +9249,16 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
}
- if zb0004 > 0 {
- zb0004--
- var zb0007 int
- zb0007, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0008 int
+ zb0008, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SelectionPK")
return
}
- if zb0007 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0007), uint64(maxAddressBytes))
+ if zb0008 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0008), uint64(maxAddressBytes))
return
}
(*z).SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).SelectionPK)
@@ -8684,26 +9267,26 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
}
- if zb0004 > 0 {
- zb0004--
- var zb0008 int
- var zb0009 bool
- zb0008, zb0009, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0009 int
+ var zb0010 bool
+ zb0009, zb0010, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0008 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0008), uint64(maxEncodedTransactionGroups))
+ if zb0009 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0009), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0009 {
+ if zb0010 {
(*z).VoteFirst = nil
- } else if (*z).VoteFirst != nil && cap((*z).VoteFirst) >= zb0008 {
- (*z).VoteFirst = ((*z).VoteFirst)[:zb0008]
+ } else if (*z).VoteFirst != nil && cap((*z).VoteFirst) >= zb0009 {
+ (*z).VoteFirst = ((*z).VoteFirst)[:zb0009]
} else {
- (*z).VoteFirst = make([]basics.Round, zb0008)
+ (*z).VoteFirst = make([]basics.Round, zb0009)
}
for zb0001 := range (*z).VoteFirst {
bts, err = (*z).VoteFirst[zb0001].UnmarshalMsg(bts)
@@ -8713,48 +9296,48 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
}
}
- if zb0004 > 0 {
- zb0004--
+ if zb0005 > 0 {
+ zb0005--
{
- var zb0010 []byte
- var zb0011 int
- zb0011, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0011 []byte
+ var zb0012 int
+ zb0012, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- if zb0011 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0011), uint64(maxBitmaskSize))
+ if zb0012 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0012), uint64(maxBitmaskSize))
return
}
- zb0010, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteFirst))
+ zb0011, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- (*z).BitmaskVoteFirst = bitmask(zb0010)
+ (*z).BitmaskVoteFirst = bitmask(zb0011)
}
}
- if zb0004 > 0 {
- zb0004--
- var zb0012 int
- var zb0013 bool
- zb0012, zb0013, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0013 int
+ var zb0014 bool
+ zb0013, zb0014, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0012 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0012), uint64(maxEncodedTransactionGroups))
+ if zb0013 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0013), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0013 {
+ if zb0014 {
(*z).VoteLast = nil
- } else if (*z).VoteLast != nil && cap((*z).VoteLast) >= zb0012 {
- (*z).VoteLast = ((*z).VoteLast)[:zb0012]
+ } else if (*z).VoteLast != nil && cap((*z).VoteLast) >= zb0013 {
+ (*z).VoteLast = ((*z).VoteLast)[:zb0013]
} else {
- (*z).VoteLast = make([]basics.Round, zb0012)
+ (*z).VoteLast = make([]basics.Round, zb0013)
}
for zb0002 := range (*z).VoteLast {
bts, err = (*z).VoteLast[zb0002].UnmarshalMsg(bts)
@@ -8764,48 +9347,48 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
}
}
- if zb0004 > 0 {
- zb0004--
+ if zb0005 > 0 {
+ zb0005--
{
- var zb0014 []byte
- var zb0015 int
- zb0015, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0015 []byte
+ var zb0016 int
+ zb0016, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- if zb0015 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0015), uint64(maxBitmaskSize))
+ if zb0016 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0016), uint64(maxBitmaskSize))
return
}
- zb0014, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteLast))
+ zb0015, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- (*z).BitmaskVoteLast = bitmask(zb0014)
+ (*z).BitmaskVoteLast = bitmask(zb0015)
}
}
- if zb0004 > 0 {
- zb0004--
- var zb0016 int
- var zb0017 bool
- zb0016, zb0017, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0017 int
+ var zb0018 bool
+ zb0017, zb0018, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0016 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0016), uint64(maxEncodedTransactionGroups))
+ if zb0017 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0017), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0017 {
+ if zb0018 {
(*z).VoteKeyDilution = nil
- } else if (*z).VoteKeyDilution != nil && cap((*z).VoteKeyDilution) >= zb0016 {
- (*z).VoteKeyDilution = ((*z).VoteKeyDilution)[:zb0016]
+ } else if (*z).VoteKeyDilution != nil && cap((*z).VoteKeyDilution) >= zb0017 {
+ (*z).VoteKeyDilution = ((*z).VoteKeyDilution)[:zb0017]
} else {
- (*z).VoteKeyDilution = make([]uint64, zb0016)
+ (*z).VoteKeyDilution = make([]uint64, zb0017)
}
for zb0003 := range (*z).VoteKeyDilution {
(*z).VoteKeyDilution[zb0003], bts, err = msgp.ReadUint64Bytes(bts)
@@ -8815,52 +9398,99 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
}
}
- if zb0004 > 0 {
- zb0004--
+ if zb0005 > 0 {
+ zb0005--
{
- var zb0018 []byte
- var zb0019 int
- zb0019, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0019 []byte
+ var zb0020 int
+ zb0020, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- if zb0019 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0019), uint64(maxBitmaskSize))
+ if zb0020 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0020), uint64(maxBitmaskSize))
return
}
- zb0018, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskKeys))
+ zb0019, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- (*z).BitmaskKeys = bitmask(zb0018)
+ (*z).BitmaskKeys = bitmask(zb0019)
}
}
- if zb0004 > 0 {
- zb0004--
+ if zb0005 > 0 {
+ zb0005--
{
- var zb0020 []byte
- var zb0021 int
- zb0021, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0021 []byte
+ var zb0022 int
+ zb0022, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- if zb0021 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0021), uint64(maxBitmaskSize))
+ if zb0022 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0022), uint64(maxBitmaskSize))
return
}
- zb0020, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskNonparticipation))
+ zb0021, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- (*z).BitmaskNonparticipation = bitmask(zb0020)
+ (*z).BitmaskNonparticipation = bitmask(zb0021)
}
}
- if zb0004 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0004)
+ if zb0005 > 0 {
+ zb0005--
+ var zb0023 int
+ var zb0024 bool
+ zb0023, zb0024, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0023 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0023), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0024 {
+ (*z).HasValidRoot = nil
+ } else if (*z).HasValidRoot != nil && cap((*z).HasValidRoot) >= zb0023 {
+ (*z).HasValidRoot = ((*z).HasValidRoot)[:zb0023]
+ } else {
+ (*z).HasValidRoot = make([]bool, zb0023)
+ }
+ for zb0004 := range (*z).HasValidRoot {
+ (*z).HasValidRoot[zb0004], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot", zb0004)
+ return
+ }
+ }
+ }
+ if zb0005 > 0 {
+ zb0005--
+ var zb0025 int
+ zb0025, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ if zb0025 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0025), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ }
+ if zb0005 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0005)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -8871,11 +9501,11 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
err = msgp.WrapError(err)
return
}
- if zb0005 {
+ if zb0006 {
(*z) = encodedKeyregTxnFields{}
}
- for zb0004 > 0 {
- zb0004--
+ for zb0005 > 0 {
+ zb0005--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -8883,14 +9513,14 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
switch string(field) {
case "votekey":
- var zb0022 int
- zb0022, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0026 int
+ zb0026, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "VotePK")
return
}
- if zb0022 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0022), uint64(maxAddressBytes))
+ if zb0026 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0026), uint64(maxAddressBytes))
return
}
(*z).VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).VotePK)
@@ -8899,14 +9529,14 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
case "selkey":
- var zb0023 int
- zb0023, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0027 int
+ zb0027, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "SelectionPK")
return
}
- if zb0023 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0023), uint64(maxAddressBytes))
+ if zb0027 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0027), uint64(maxAddressBytes))
return
}
(*z).SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).SelectionPK)
@@ -8915,24 +9545,24 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
case "votefst":
- var zb0024 int
- var zb0025 bool
- zb0024, zb0025, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0028 int
+ var zb0029 bool
+ zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0024 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0024), uint64(maxEncodedTransactionGroups))
+ if zb0028 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0028), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0025 {
+ if zb0029 {
(*z).VoteFirst = nil
- } else if (*z).VoteFirst != nil && cap((*z).VoteFirst) >= zb0024 {
- (*z).VoteFirst = ((*z).VoteFirst)[:zb0024]
+ } else if (*z).VoteFirst != nil && cap((*z).VoteFirst) >= zb0028 {
+ (*z).VoteFirst = ((*z).VoteFirst)[:zb0028]
} else {
- (*z).VoteFirst = make([]basics.Round, zb0024)
+ (*z).VoteFirst = make([]basics.Round, zb0028)
}
for zb0001 := range (*z).VoteFirst {
bts, err = (*z).VoteFirst[zb0001].UnmarshalMsg(bts)
@@ -8943,43 +9573,43 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
case "votefstbm":
{
- var zb0026 []byte
- var zb0027 int
- zb0027, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0030 []byte
+ var zb0031 int
+ zb0031, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- if zb0027 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0027), uint64(maxBitmaskSize))
+ if zb0031 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0031), uint64(maxBitmaskSize))
return
}
- zb0026, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteFirst))
+ zb0030, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- (*z).BitmaskVoteFirst = bitmask(zb0026)
+ (*z).BitmaskVoteFirst = bitmask(zb0030)
}
case "votelst":
- var zb0028 int
- var zb0029 bool
- zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0032 int
+ var zb0033 bool
+ zb0032, zb0033, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0028 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0028), uint64(maxEncodedTransactionGroups))
+ if zb0032 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0032), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0029 {
+ if zb0033 {
(*z).VoteLast = nil
- } else if (*z).VoteLast != nil && cap((*z).VoteLast) >= zb0028 {
- (*z).VoteLast = ((*z).VoteLast)[:zb0028]
+ } else if (*z).VoteLast != nil && cap((*z).VoteLast) >= zb0032 {
+ (*z).VoteLast = ((*z).VoteLast)[:zb0032]
} else {
- (*z).VoteLast = make([]basics.Round, zb0028)
+ (*z).VoteLast = make([]basics.Round, zb0032)
}
for zb0002 := range (*z).VoteLast {
bts, err = (*z).VoteLast[zb0002].UnmarshalMsg(bts)
@@ -8990,43 +9620,43 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
case "votelstbm":
{
- var zb0030 []byte
- var zb0031 int
- zb0031, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0034 []byte
+ var zb0035 int
+ zb0035, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- if zb0031 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0031), uint64(maxBitmaskSize))
+ if zb0035 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0035), uint64(maxBitmaskSize))
return
}
- zb0030, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteLast))
+ zb0034, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- (*z).BitmaskVoteLast = bitmask(zb0030)
+ (*z).BitmaskVoteLast = bitmask(zb0034)
}
case "votekd":
- var zb0032 int
- var zb0033 bool
- zb0032, zb0033, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0036 int
+ var zb0037 bool
+ zb0036, zb0037, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0032 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0032), uint64(maxEncodedTransactionGroups))
+ if zb0036 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0036), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0033 {
+ if zb0037 {
(*z).VoteKeyDilution = nil
- } else if (*z).VoteKeyDilution != nil && cap((*z).VoteKeyDilution) >= zb0032 {
- (*z).VoteKeyDilution = ((*z).VoteKeyDilution)[:zb0032]
+ } else if (*z).VoteKeyDilution != nil && cap((*z).VoteKeyDilution) >= zb0036 {
+ (*z).VoteKeyDilution = ((*z).VoteKeyDilution)[:zb0036]
} else {
- (*z).VoteKeyDilution = make([]uint64, zb0032)
+ (*z).VoteKeyDilution = make([]uint64, zb0036)
}
for zb0003 := range (*z).VoteKeyDilution {
(*z).VoteKeyDilution[zb0003], bts, err = msgp.ReadUint64Bytes(bts)
@@ -9037,43 +9667,86 @@ func (z *encodedKeyregTxnFields) UnmarshalMsg(bts []byte) (o []byte, err error)
}
case "votekbm":
{
- var zb0034 []byte
- var zb0035 int
- zb0035, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0038 []byte
+ var zb0039 int
+ zb0039, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- if zb0035 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0035), uint64(maxBitmaskSize))
+ if zb0039 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0039), uint64(maxBitmaskSize))
return
}
- zb0034, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskKeys))
+ zb0038, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- (*z).BitmaskKeys = bitmask(zb0034)
+ (*z).BitmaskKeys = bitmask(zb0038)
}
case "nonpartbm":
{
- var zb0036 []byte
- var zb0037 int
- zb0037, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0040 []byte
+ var zb0041 int
+ zb0041, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- if zb0037 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0037), uint64(maxBitmaskSize))
+ if zb0041 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0041), uint64(maxBitmaskSize))
return
}
- zb0036, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskNonparticipation))
+ zb0040, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- (*z).BitmaskNonparticipation = bitmask(zb0036)
+ (*z).BitmaskNonparticipation = bitmask(zb0040)
+ }
+ case "vldrt":
+ var zb0042 int
+ var zb0043 bool
+ zb0042, zb0043, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0042 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0042), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0043 {
+ (*z).HasValidRoot = nil
+ } else if (*z).HasValidRoot != nil && cap((*z).HasValidRoot) >= zb0042 {
+ (*z).HasValidRoot = ((*z).HasValidRoot)[:zb0042]
+ } else {
+ (*z).HasValidRoot = make([]bool, zb0042)
+ }
+ for zb0004 := range (*z).HasValidRoot {
+ (*z).HasValidRoot[zb0004], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot", zb0004)
+ return
+ }
+ }
+ case "comt":
+ var zb0044 int
+ zb0044, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
+ }
+ if zb0044 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0044), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
}
default:
err = msgp.ErrNoField(string(field))
@@ -9103,13 +9776,13 @@ func (z *encodedKeyregTxnFields) Msgsize() (s int) {
for zb0002 := range (*z).VoteLast {
s += (*z).VoteLast[zb0002].Msgsize()
}
- s += 10 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskNonparticipation))
+ s += 10 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).BitmaskNonparticipation)) + 6 + msgp.ArrayHeaderSize + (len((*z).HasValidRoot) * (msgp.BoolSize)) + 5 + msgp.BytesPrefixSize + len((*z).CommitmentRoot)
return
}
// MsgIsZero returns whether this is a zero value
func (z *encodedKeyregTxnFields) MsgIsZero() bool {
- return (len((*z).VotePK) == 0) && (len((*z).SelectionPK) == 0) && (len((*z).VoteFirst) == 0) && (len((*z).BitmaskVoteFirst) == 0) && (len((*z).VoteLast) == 0) && (len((*z).BitmaskVoteLast) == 0) && (len((*z).VoteKeyDilution) == 0) && (len((*z).BitmaskKeys) == 0) && (len((*z).BitmaskNonparticipation) == 0)
+ return (len((*z).VotePK) == 0) && (len((*z).SelectionPK) == 0) && (len((*z).VoteFirst) == 0) && (len((*z).BitmaskVoteFirst) == 0) && (len((*z).VoteLast) == 0) && (len((*z).BitmaskVoteLast) == 0) && (len((*z).VoteKeyDilution) == 0) && (len((*z).BitmaskKeys) == 0) && (len((*z).BitmaskNonparticipation) == 0) && (len((*z).HasValidRoot) == 0) && (len((*z).CommitmentRoot) == 0)
}
// MarshalMsg implements msgp.Marshaler
@@ -10393,516 +11066,540 @@ func (z *encodedPaymentTxnFields) MsgIsZero() bool {
func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0049Len := uint32(126)
- var zb0049Mask [3]uint64 /* 140 bits */
+ zb0053Len := uint32(132)
+ var zb0053Mask [3]uint64 /* 146 bits */
if len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000
}
if len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000
}
if len((*z).encodedTxns.encodedPaymentTxnFields.Amount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000
}
if len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000000000
+ }
+ if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000000000
+ }
+ if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000000000
+ }
+ if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000000000
+ }
+ if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000000000
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.CertType) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1
+ zb0053Len--
+ zb0053Mask[1] |= 0x10
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2
+ zb0053Len--
+ zb0053Mask[1] |= 0x20
}
if len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4
+ zb0053Len--
+ zb0053Mask[1] |= 0x40
}
if len((*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8
+ zb0053Len--
+ zb0053Mask[1] |= 0x80
}
if len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10
+ zb0053Len--
+ zb0053Mask[1] |= 0x100
+ }
+ if len((*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot) == 0 {
+ zb0053Len--
+ zb0053Mask[1] |= 0x200
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20
+ zb0053Len--
+ zb0053Mask[1] |= 0x400
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40
+ zb0053Len--
+ zb0053Mask[1] |= 0x800
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000
}
if len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000
}
if len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000
}
if len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000
}
if len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000
}
if len((*z).encodedTxns.encodedTxnHeaders.Fee) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskFee) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000
}
if len((*z).encodedTxns.encodedTxnHeaders.FirstValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000
}
if len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000
}
if len((*z).encodedLsigs.LogicArgs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000
}
if len((*z).encodedLsigs.BitmaskLogicArgs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000
}
if len((*z).encodedLsigs.Logic) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000
}
if len((*z).encodedLsigs.BitmaskLogic) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.LastValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.Lease) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskLease) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000000
}
if len((*z).encodedMsigs.Threshold) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000000
}
if len((*z).encodedMsigs.BitmaskThreshold) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000000
}
if len((*z).encodedMsigs.Version) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000000
}
if len((*z).encodedMsigs.BitmaskVersion) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000000
}
if len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.Note) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskNote) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000000
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000000
}
if len((*z).encodedTxns.encodedPaymentTxnFields.Receiver) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000000000
}
if len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.RekeyTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000000000
}
if len((*z).encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000000000
}
if len((*z).AuthAddr) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000000000
}
if len((*z).BitmaskAuthAddr) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000000000
}
if len((*z).Sig) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000000000
}
if len((*z).BitmaskSig) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.Sender) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000000000
}
if len((*z).encodedTxns.encodedTxnHeaders.BitmaskSender) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000000000
}
if len((*z).encodedMsigs.Subsigs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000000000
}
if len((*z).encodedMsigs.BitmaskSubsigs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x1
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x2
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x4
}
if len((*z).encodedTxns.TxType) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x8
}
if len((*z).encodedTxns.BitmaskTxType) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x10
}
if (*z).encodedTxns.TxTypeOffset == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x1
+ zb0053Len--
+ zb0053Mask[2] |= 0x20
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x2
+ zb0053Len--
+ zb0053Mask[2] |= 0x40
}
if len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x4
+ zb0053Len--
+ zb0053Mask[2] |= 0x80
+ }
+ if len((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot) == 0 {
+ zb0053Len--
+ zb0053Mask[2] |= 0x100
}
if len((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x8
+ zb0053Len--
+ zb0053Mask[2] |= 0x200
}
if len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x10
+ zb0053Len--
+ zb0053Mask[2] |= 0x400
}
if len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x20
+ zb0053Len--
+ zb0053Mask[2] |= 0x800
}
if len((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x40
+ zb0053Len--
+ zb0053Mask[2] |= 0x1000
}
if len((*z).encodedTxns.encodedKeyregTxnFields.VotePK) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x80
+ zb0053Len--
+ zb0053Mask[2] |= 0x2000
}
if len((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x100
+ zb0053Len--
+ zb0053Mask[2] |= 0x4000
}
if len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x200
+ zb0053Len--
+ zb0053Mask[2] |= 0x8000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x400
+ zb0053Len--
+ zb0053Mask[2] |= 0x10000
}
if len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x800
+ zb0053Len--
+ zb0053Mask[2] |= 0x20000
}
- // variable map header, size zb0049Len
- o = msgp.AppendMapHeader(o, zb0049Len)
- if zb0049Len != 0 {
- if (zb0049Mask[0] & 0x4000) == 0 { // if not empty
+ // variable map header, size zb0053Len
+ o = msgp.AppendMapHeader(o, zb0053Len)
+ if zb0053Len != 0 {
+ if (zb0053Mask[0] & 0x4000) == 0 { // if not empty
// string "aamt"
o = append(o, 0xa4, 0x61, 0x61, 0x6d, 0x74)
if (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount == nil {
@@ -10910,41 +11607,41 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount)))
}
- for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021])
+ for zb0022 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022])
}
}
- if (zb0049Mask[0] & 0x8000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000) == 0 { // if not empty
// string "aamtbm"
o = append(o, 0xa6, 0x61, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
}
- if (zb0049Mask[0] & 0x10000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000) == 0 { // if not empty
// string "aclose"
o = append(o, 0xa6, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
}
- if (zb0049Mask[0] & 0x20000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000) == 0 { // if not empty
// string "aclosebm"
o = append(o, 0xa8, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
}
- if (zb0049Mask[0] & 0x40000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000) == 0 { // if not empty
// string "afrzbm"
o = append(o, 0xa6, 0x61, 0x66, 0x72, 0x7a, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
}
- if (zb0049Mask[0] & 0x80000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000) == 0 { // if not empty
// string "am"
o = append(o, 0xa2, 0x61, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
}
- if (zb0049Mask[0] & 0x100000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000) == 0 { // if not empty
// string "ambm"
o = append(o, 0xa4, 0x61, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
}
- if (zb0049Mask[0] & 0x200000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000) == 0 { // if not empty
// string "amt"
o = append(o, 0xa3, 0x61, 0x6d, 0x74)
if (*z).encodedTxns.encodedPaymentTxnFields.Amount == nil {
@@ -10952,16 +11649,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedPaymentTxnFields.Amount)))
}
- for zb0013 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
- o = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0013].MarshalMsg(o)
+ for zb0014 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
+ o = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0014].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x400000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000) == 0 { // if not empty
// string "amtbm"
o = append(o, 0xa5, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
}
- if (zb0049Mask[0] & 0x800000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000) == 0 { // if not empty
// string "an"
o = append(o, 0xa2, 0x61, 0x6e)
if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName == nil {
@@ -10969,16 +11666,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)))
}
- for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018])
+ for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019])
}
}
- if (zb0049Mask[0] & 0x1000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000) == 0 { // if not empty
// string "anbm"
o = append(o, 0xa4, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
}
- if (zb0049Mask[0] & 0x2000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000) == 0 { // if not empty
// string "apaa"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x61)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs == nil {
@@ -10986,33 +11683,33 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)))
}
- for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] == nil {
+ for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])))
}
- for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- o = msgp.AppendBytes(o, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ o = msgp.AppendBytes(o, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
}
}
}
- if (zb0049Mask[0] & 0x4000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000) == 0 { // if not empty
// string "apaabm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
}
- if (zb0049Mask[0] & 0x8000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000) == 0 { // if not empty
// string "apan"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x6e)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
}
- if (zb0049Mask[0] & 0x10000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000) == 0 { // if not empty
// string "apanbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
}
- if (zb0049Mask[0] & 0x20000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000) == 0 { // if not empty
// string "apap"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x70)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram == nil {
@@ -11020,16 +11717,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)))
}
- for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
}
}
- if (zb0049Mask[0] & 0x40000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000) == 0 { // if not empty
// string "apapbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
}
- if (zb0049Mask[0] & 0x80000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000000) == 0 { // if not empty
// string "apas"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x73)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets == nil {
@@ -11037,23 +11734,23 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)))
}
- for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] == nil {
+ for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])))
}
- for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- o = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].MarshalMsg(o)
+ for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ o = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x100000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000000) == 0 { // if not empty
// string "apasbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
}
- if (zb0049Mask[0] & 0x200000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000000) == 0 { // if not empty
// string "apat"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x74)
if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts == nil {
@@ -11061,23 +11758,23 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts)))
}
- for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
- if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] == nil {
+ for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])))
}
- for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- o = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].MarshalMsg(o)
+ for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ o = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x400000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000) == 0 { // if not empty
// string "apatbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
}
- if (zb0049Mask[0] & 0x800000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000000) == 0 { // if not empty
// string "apep"
o = append(o, 0xa4, 0x61, 0x70, 0x65, 0x70)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages == nil {
@@ -11085,16 +11782,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)))
}
- for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- o = msgp.AppendUint32(o, (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038])
+ for zb0039 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ o = msgp.AppendUint32(o, (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039])
}
}
- if (zb0049Mask[0] & 0x1000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000000) == 0 { // if not empty
// string "apepbm"
o = append(o, 0xa6, 0x61, 0x70, 0x65, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
}
- if (zb0049Mask[0] & 0x2000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000000) == 0 { // if not empty
// string "apfa"
o = append(o, 0xa4, 0x61, 0x70, 0x66, 0x61)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps == nil {
@@ -11102,23 +11799,23 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps)))
}
- for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] == nil {
+ for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])))
}
- for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- o = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].MarshalMsg(o)
+ for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ o = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x4000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000) == 0 { // if not empty
// string "apfabm"
o = append(o, 0xa6, 0x61, 0x70, 0x66, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
}
- if (zb0049Mask[0] & 0x8000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000) == 0 { // if not empty
// string "apid"
o = append(o, 0xa4, 0x61, 0x70, 0x69, 0x64)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID == nil {
@@ -11126,16 +11823,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID)))
}
- for zb0023 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- o = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].MarshalMsg(o)
+ for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ o = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x10000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000000) == 0 { // if not empty
// string "apidbm"
o = append(o, 0xa6, 0x61, 0x70, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
}
- if (zb0049Mask[0] & 0x20000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000000) == 0 { // if not empty
// string "apsu"
o = append(o, 0xa4, 0x61, 0x70, 0x73, 0x75)
if (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram == nil {
@@ -11143,36 +11840,36 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)))
}
- for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
}
}
- if (zb0049Mask[0] & 0x40000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000000) == 0 { // if not empty
// string "apsubm"
o = append(o, 0xa6, 0x61, 0x70, 0x73, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
}
- if (zb0049Mask[0] & 0x80000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000000000) == 0 { // if not empty
// string "arcv"
o = append(o, 0xa4, 0x61, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
}
- if (zb0049Mask[0] & 0x100000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000000000) == 0 { // if not empty
// string "arcvbm"
o = append(o, 0xa6, 0x61, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
}
- if (zb0049Mask[0] & 0x200000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000000000) == 0 { // if not empty
// string "asnd"
o = append(o, 0xa4, 0x61, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender)
}
- if (zb0049Mask[0] & 0x400000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000000) == 0 { // if not empty
// string "asndbm"
o = append(o, 0xa6, 0x61, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
}
- if (zb0049Mask[0] & 0x800000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000000000) == 0 { // if not empty
// string "au"
o = append(o, 0xa2, 0x61, 0x75)
if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL == nil {
@@ -11180,21 +11877,21 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)))
}
- for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019])
+ for zb0020 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020])
}
}
- if (zb0049Mask[0] & 0x1000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000000000) == 0 { // if not empty
// string "aubm"
o = append(o, 0xa4, 0x61, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
}
- if (zb0049Mask[0] & 0x2000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000000000) == 0 { // if not empty
// string "c"
o = append(o, 0xa1, 0x63)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
}
- if (zb0049Mask[0] & 0x4000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000000) == 0 { // if not empty
// string "caid"
o = append(o, 0xa4, 0x63, 0x61, 0x69, 0x64)
if (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset == nil {
@@ -11202,21 +11899,21 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)))
}
- for zb0014 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- o = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].MarshalMsg(o)
+ for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ o = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x8000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000000) == 0 { // if not empty
// string "caidbm"
o = append(o, 0xa6, 0x63, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
}
- if (zb0049Mask[0] & 0x10000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000000000) == 0 { // if not empty
// string "cbm"
o = append(o, 0xa3, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
}
- if (zb0049Mask[0] & 0x20000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000000000) == 0 { // if not empty
// string "certP"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x50)
if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs == nil {
@@ -11224,23 +11921,40 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)))
}
- for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] == nil {
+ for zb0047 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])))
}
- for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- o = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].MarshalMsg(o)
+ for zb0048 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ o = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x40000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000000000) == 0 { // if not empty
+ // string "certPH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48)
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)))
+ }
+ for zb0049 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049])
+ }
+ }
+ if (zb0053Mask[0] & 0x80000000000000) == 0 { // if not empty
+ // string "certPHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ }
+ if (zb0053Mask[0] & 0x100000000000000) == 0 { // if not empty
// string "certPbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x50, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
}
- if (zb0049Mask[0] & 0x80000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000000000000) == 0 { // if not empty
// string "certS"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x53)
if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs == nil {
@@ -11248,33 +11962,57 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)))
}
- for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] == nil {
+ for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])))
}
- for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- o = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].MarshalMsg(o)
+ for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ o = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x100000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000000000) == 0 { // if not empty
+ // string "certSH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48)
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)))
+ }
+ for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046])
+ }
+ }
+ if (zb0053Mask[0] & 0x800000000000000) == 0 { // if not empty
+ // string "certSHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ }
+ if (zb0053Mask[0] & 0x1000000000000000) == 0 { // if not empty
// string "certSbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x53, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
}
- if (zb0049Mask[0] & 0x200000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000000000000) == 0 { // if not empty
// string "certc"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x63)
- o = msgp.AppendBytes(o, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)))
+ }
+ for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ o = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].MarshalMsg(o)
+ }
}
- if (zb0049Mask[0] & 0x400000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000000000) == 0 { // if not empty
// string "certcbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
}
- if (zb0049Mask[0] & 0x800000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000000000) == 0 { // if not empty
// string "certr"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x72)
if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals == nil {
@@ -11282,31 +12020,31 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)))
}
- for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
+ for zb0050 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046])))
+ o = msgp.AppendMapHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050])))
}
- zb0047_keys := make([]uint64, 0, len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046]))
- for zb0047 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] {
- zb0047_keys = append(zb0047_keys, zb0047)
+ zb0051_keys := make([]uint64, 0, len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050]))
+ for zb0051 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] {
+ zb0051_keys = append(zb0051_keys, zb0051)
}
- sort.Sort(SortUint64(zb0047_keys))
- for _, zb0047 := range zb0047_keys {
- zb0048 := (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047]
- _ = zb0048
- o = msgp.AppendUint64(o, zb0047)
- o = zb0048.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0051_keys))
+ for _, zb0051 := range zb0051_keys {
+ zb0052 := (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051]
+ _ = zb0052
+ o = msgp.AppendUint64(o, zb0051)
+ o = zb0052.MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x1000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1) == 0 { // if not empty
// string "certrbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
}
- if (zb0049Mask[0] & 0x2000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2) == 0 { // if not empty
// string "certrnd"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64)
if (*z).encodedTxns.encodedCompactCertTxnFields.CertRound == nil {
@@ -11314,16 +12052,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.CertRound)))
}
- for zb0039 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
- o = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].MarshalMsg(o)
+ for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
+ o = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x4000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4) == 0 { // if not empty
// string "certrndbm"
o = append(o, 0xa9, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
}
- if (zb0049Mask[0] & 0x8000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8) == 0 { // if not empty
// string "certtype"
o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65)
if (*z).encodedTxns.encodedCompactCertTxnFields.CertType == nil {
@@ -11331,16 +12069,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.CertType)))
}
- for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
- o = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].MarshalMsg(o)
+ for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
+ o = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x1) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10) == 0 { // if not empty
// string "certtypebm"
o = append(o, 0xaa, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
}
- if (zb0049Mask[1] & 0x2) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20) == 0 { // if not empty
// string "certw"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x77)
if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight == nil {
@@ -11348,26 +12086,31 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)))
}
- for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041])
+ for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043])
}
}
- if (zb0049Mask[1] & 0x4) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40) == 0 { // if not empty
// string "certwbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x77, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
}
- if (zb0049Mask[1] & 0x8) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80) == 0 { // if not empty
// string "close"
o = append(o, 0xa5, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
}
- if (zb0049Mask[1] & 0x10) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100) == 0 { // if not empty
// string "closebm"
o = append(o, 0xa7, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
}
- if (zb0049Mask[1] & 0x20) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200) == 0 { // if not empty
+ // string "comt"
+ o = append(o, 0xa4, 0x63, 0x6f, 0x6d, 0x74)
+ o = msgp.AppendBytes(o, (*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ }
+ if (zb0053Mask[1] & 0x400) == 0 { // if not empty
// string "dc"
o = append(o, 0xa2, 0x64, 0x63)
if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals == nil {
@@ -11375,36 +12118,36 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)))
}
- for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- o = msgp.AppendUint32(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016])
+ for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ o = msgp.AppendUint32(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017])
}
}
- if (zb0049Mask[1] & 0x40) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800) == 0 { // if not empty
// string "dcbm"
o = append(o, 0xa4, 0x64, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
}
- if (zb0049Mask[1] & 0x80) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000) == 0 { // if not empty
// string "dfbm"
o = append(o, 0xa4, 0x64, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
}
- if (zb0049Mask[1] & 0x100) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000) == 0 { // if not empty
// string "f"
o = append(o, 0xa1, 0x66)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
}
- if (zb0049Mask[1] & 0x200) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000) == 0 { // if not empty
// string "fadd"
o = append(o, 0xa4, 0x66, 0x61, 0x64, 0x64)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
}
- if (zb0049Mask[1] & 0x400) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000) == 0 { // if not empty
// string "faddbm"
o = append(o, 0xa6, 0x66, 0x61, 0x64, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
}
- if (zb0049Mask[1] & 0x800) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000) == 0 { // if not empty
// string "faid"
o = append(o, 0xa4, 0x66, 0x61, 0x69, 0x64)
if (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset == nil {
@@ -11412,21 +12155,21 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)))
}
- for zb0022 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- o = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].MarshalMsg(o)
+ for zb0023 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ o = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x1000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000) == 0 { // if not empty
// string "faidbm"
o = append(o, 0xa6, 0x66, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
}
- if (zb0049Mask[1] & 0x2000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000) == 0 { // if not empty
// string "fbm"
o = append(o, 0xa3, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
}
- if (zb0049Mask[1] & 0x4000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000) == 0 { // if not empty
// string "fee"
o = append(o, 0xa3, 0x66, 0x65, 0x65)
if (*z).encodedTxns.encodedTxnHeaders.Fee == nil {
@@ -11438,12 +12181,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxns.encodedTxnHeaders.Fee[zb0006].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x8000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000) == 0 { // if not empty
// string "feebm"
o = append(o, 0xa5, 0x66, 0x65, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFee))
}
- if (zb0049Mask[1] & 0x10000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000) == 0 { // if not empty
// string "fv"
o = append(o, 0xa2, 0x66, 0x76)
if (*z).encodedTxns.encodedTxnHeaders.FirstValid == nil {
@@ -11455,17 +12198,17 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxns.encodedTxnHeaders.FirstValid[zb0007].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x20000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000) == 0 { // if not empty
// string "fvbm"
o = append(o, 0xa4, 0x66, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
}
- if (zb0049Mask[1] & 0x40000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000) == 0 { // if not empty
// string "genbm"
o = append(o, 0xa5, 0x67, 0x65, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
}
- if (zb0049Mask[1] & 0x80000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000) == 0 { // if not empty
// string "gnbs"
o = append(o, 0xa4, 0x67, 0x6e, 0x62, 0x73)
if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice == nil {
@@ -11473,16 +12216,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)))
}
- for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035])
+ for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036])
}
}
- if (zb0049Mask[1] & 0x100000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000) == 0 { // if not empty
// string "gnbsbm"
o = append(o, 0xa6, 0x67, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
}
- if (zb0049Mask[1] & 0x200000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000) == 0 { // if not empty
// string "gnui"
o = append(o, 0xa4, 0x67, 0x6e, 0x75, 0x69)
if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint == nil {
@@ -11490,21 +12233,21 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)))
}
- for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034])
+ for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035])
}
}
- if (zb0049Mask[1] & 0x400000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000) == 0 { // if not empty
// string "gnuibm"
o = append(o, 0xa6, 0x67, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
}
- if (zb0049Mask[1] & 0x800000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000) == 0 { // if not empty
// string "grpbm"
o = append(o, 0xa5, 0x67, 0x72, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup))
}
- if (zb0049Mask[1] & 0x1000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000) == 0 { // if not empty
// string "lnbs"
o = append(o, 0xa4, 0x6c, 0x6e, 0x62, 0x73)
if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice == nil {
@@ -11512,16 +12255,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)))
}
- for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033])
+ for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034])
}
}
- if (zb0049Mask[1] & 0x2000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000) == 0 { // if not empty
// string "lnbsbm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
}
- if (zb0049Mask[1] & 0x4000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000) == 0 { // if not empty
// string "lnui"
o = append(o, 0xa4, 0x6c, 0x6e, 0x75, 0x69)
if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint == nil {
@@ -11529,16 +12272,16 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)))
}
- for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032])
+ for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033])
}
}
- if (zb0049Mask[1] & 0x8000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000) == 0 { // if not empty
// string "lnuibm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
}
- if (zb0049Mask[1] & 0x10000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000) == 0 { // if not empty
// string "lsigarg"
o = append(o, 0xa7, 0x6c, 0x73, 0x69, 0x67, 0x61, 0x72, 0x67)
if (*z).encodedLsigs.LogicArgs == nil {
@@ -11557,12 +12300,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
}
}
}
- if (zb0049Mask[1] & 0x20000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000) == 0 { // if not empty
// string "lsigargbm"
o = append(o, 0xa9, 0x6c, 0x73, 0x69, 0x67, 0x61, 0x72, 0x67, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedLsigs.BitmaskLogicArgs))
}
- if (zb0049Mask[1] & 0x40000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000) == 0 { // if not empty
// string "lsigl"
o = append(o, 0xa5, 0x6c, 0x73, 0x69, 0x67, 0x6c)
if (*z).encodedLsigs.Logic == nil {
@@ -11574,12 +12317,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendBytes(o, (*z).encodedLsigs.Logic[zb0003])
}
}
- if (zb0049Mask[1] & 0x80000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000) == 0 { // if not empty
// string "lsiglbm"
o = append(o, 0xa7, 0x6c, 0x73, 0x69, 0x67, 0x6c, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedLsigs.BitmaskLogic))
}
- if (zb0049Mask[1] & 0x100000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000) == 0 { // if not empty
// string "lv"
o = append(o, 0xa2, 0x6c, 0x76)
if (*z).encodedTxns.encodedTxnHeaders.LastValid == nil {
@@ -11591,57 +12334,57 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxns.encodedTxnHeaders.LastValid[zb0008].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x200000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000) == 0 { // if not empty
// string "lvbm"
o = append(o, 0xa4, 0x6c, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid))
}
- if (zb0049Mask[1] & 0x400000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000) == 0 { // if not empty
// string "lx"
o = append(o, 0xa2, 0x6c, 0x78)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedTxnHeaders.Lease)
}
- if (zb0049Mask[1] & 0x800000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000000) == 0 { // if not empty
// string "lxbm"
o = append(o, 0xa4, 0x6c, 0x78, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLease))
}
- if (zb0049Mask[1] & 0x1000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000000) == 0 { // if not empty
// string "m"
o = append(o, 0xa1, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
}
- if (zb0049Mask[1] & 0x2000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000000) == 0 { // if not empty
// string "mbm"
o = append(o, 0xa3, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
}
- if (zb0049Mask[1] & 0x4000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000000) == 0 { // if not empty
// string "msigthr"
o = append(o, 0xa7, 0x6d, 0x73, 0x69, 0x67, 0x74, 0x68, 0x72)
o = msgp.AppendBytes(o, (*z).encodedMsigs.Threshold)
}
- if (zb0049Mask[1] & 0x8000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000000) == 0 { // if not empty
// string "msigthrbm"
o = append(o, 0xa9, 0x6d, 0x73, 0x69, 0x67, 0x74, 0x68, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedMsigs.BitmaskThreshold))
}
- if (zb0049Mask[1] & 0x10000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000000) == 0 { // if not empty
// string "msigv"
o = append(o, 0xa5, 0x6d, 0x73, 0x69, 0x67, 0x76)
o = msgp.AppendBytes(o, (*z).encodedMsigs.Version)
}
- if (zb0049Mask[1] & 0x20000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000000) == 0 { // if not empty
// string "msigvbm"
o = append(o, 0xa7, 0x6d, 0x73, 0x69, 0x67, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedMsigs.BitmaskVersion))
}
- if (zb0049Mask[1] & 0x40000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000000) == 0 { // if not empty
// string "nonpartbm"
o = append(o, 0xa9, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
}
- if (zb0049Mask[1] & 0x80000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000000) == 0 { // if not empty
// string "note"
o = append(o, 0xa4, 0x6e, 0x6f, 0x74, 0x65)
if (*z).encodedTxns.encodedTxnHeaders.Note == nil {
@@ -11653,77 +12396,77 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedTxnHeaders.Note[zb0009])
}
}
- if (zb0049Mask[1] & 0x100000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000000) == 0 { // if not empty
// string "notebm"
o = append(o, 0xa6, 0x6e, 0x6f, 0x74, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskNote))
}
- if (zb0049Mask[1] & 0x200000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000000) == 0 { // if not empty
// string "r"
o = append(o, 0xa1, 0x72)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
}
- if (zb0049Mask[1] & 0x400000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000000) == 0 { // if not empty
// string "rbm"
o = append(o, 0xa3, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
}
- if (zb0049Mask[1] & 0x800000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000000000) == 0 { // if not empty
// string "rcv"
o = append(o, 0xa3, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedPaymentTxnFields.Receiver)
}
- if (zb0049Mask[1] & 0x1000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000000000) == 0 { // if not empty
// string "rcvbm"
o = append(o, 0xa5, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
}
- if (zb0049Mask[1] & 0x2000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000000000) == 0 { // if not empty
// string "rekey"
o = append(o, 0xa5, 0x72, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedTxnHeaders.RekeyTo)
}
- if (zb0049Mask[1] & 0x4000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000000000) == 0 { // if not empty
// string "rekeybm"
o = append(o, 0xa7, 0x72, 0x65, 0x6b, 0x65, 0x79, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
}
- if (zb0049Mask[1] & 0x8000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000000000) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedKeyregTxnFields.SelectionPK)
}
- if (zb0049Mask[1] & 0x10000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000000000) == 0 { // if not empty
// string "sgnr"
o = append(o, 0xa4, 0x73, 0x67, 0x6e, 0x72)
o = msgp.AppendBytes(o, (*z).AuthAddr)
}
- if (zb0049Mask[1] & 0x20000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000000000) == 0 { // if not empty
// string "sgnrbm"
o = append(o, 0xa6, 0x73, 0x67, 0x6e, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskAuthAddr))
}
- if (zb0049Mask[1] & 0x40000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000000000) == 0 { // if not empty
// string "sig"
o = append(o, 0xa3, 0x73, 0x69, 0x67)
o = msgp.AppendBytes(o, (*z).Sig)
}
- if (zb0049Mask[1] & 0x80000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000000000) == 0 { // if not empty
// string "sigbm"
o = append(o, 0xa5, 0x73, 0x69, 0x67, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskSig))
}
- if (zb0049Mask[1] & 0x100000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000000000) == 0 { // if not empty
// string "snd"
o = append(o, 0xa3, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedTxnHeaders.Sender)
}
- if (zb0049Mask[1] & 0x200000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000000000) == 0 { // if not empty
// string "sndbm"
o = append(o, 0xa5, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskSender))
}
- if (zb0049Mask[1] & 0x400000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000000000) == 0 { // if not empty
// string "subsig"
o = append(o, 0xa6, 0x73, 0x75, 0x62, 0x73, 0x69, 0x67)
if (*z).encodedMsigs.Subsigs == nil {
@@ -11742,12 +12485,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
}
}
}
- if (zb0049Mask[1] & 0x800000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x1) == 0 { // if not empty
// string "subsigsbm"
o = append(o, 0xa9, 0x73, 0x75, 0x62, 0x73, 0x69, 0x67, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedMsigs.BitmaskSubsigs))
}
- if (zb0049Mask[1] & 0x1000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x2) == 0 { // if not empty
// string "t"
o = append(o, 0xa1, 0x74)
if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total == nil {
@@ -11755,31 +12498,31 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)))
}
- for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- o = msgp.AppendUint64(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015])
+ for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ o = msgp.AppendUint64(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016])
}
}
- if (zb0049Mask[1] & 0x2000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x4) == 0 { // if not empty
// string "tbm"
o = append(o, 0xa3, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
}
- if (zb0049Mask[1] & 0x4000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x8) == 0 { // if not empty
// string "type"
o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
o = msgp.AppendBytes(o, (*z).encodedTxns.TxType)
}
- if (zb0049Mask[1] & 0x8000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x10) == 0 { // if not empty
// string "typebm"
o = append(o, 0xa6, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.BitmaskTxType))
}
- if (zb0049Mask[2] & 0x1) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x20) == 0 { // if not empty
// string "typeo"
o = append(o, 0xa5, 0x74, 0x79, 0x70, 0x65, 0x6f)
o = msgp.AppendByte(o, (*z).encodedTxns.TxTypeOffset)
}
- if (zb0049Mask[2] & 0x2) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x40) == 0 { // if not empty
// string "un"
o = append(o, 0xa2, 0x75, 0x6e)
if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName == nil {
@@ -11787,16 +12530,28 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)))
}
- for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017])
+ for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ o = msgp.AppendString(o, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018])
}
}
- if (zb0049Mask[2] & 0x4) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x80) == 0 { // if not empty
// string "unbm"
o = append(o, 0xa4, 0x75, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
}
- if (zb0049Mask[2] & 0x8) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x100) == 0 { // if not empty
+ // string "vldrt"
+ o = append(o, 0xa5, 0x76, 0x6c, 0x64, 0x72, 0x74)
+ if (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot)))
+ }
+ for zb0013 := range (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ o = msgp.AppendBool(o, (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013])
+ }
+ }
+ if (zb0053Mask[2] & 0x200) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
if (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst == nil {
@@ -11808,17 +12563,17 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x10) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x400) == 0 { // if not empty
// string "votefstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
}
- if (zb0049Mask[2] & 0x20) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x800) == 0 { // if not empty
// string "votekbm"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
}
- if (zb0049Mask[2] & 0x40) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x1000) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
if (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution == nil {
@@ -11830,12 +12585,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012])
}
}
- if (zb0049Mask[2] & 0x80) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x2000) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedTxns.encodedKeyregTxnFields.VotePK)
}
- if (zb0049Mask[2] & 0x100) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x4000) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
if (*z).encodedTxns.encodedKeyregTxnFields.VoteLast == nil {
@@ -11847,12 +12602,12 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x200) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x8000) == 0 { // if not empty
// string "votelstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
}
- if (zb0049Mask[2] & 0x400) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x10000) == 0 { // if not empty
// string "xaid"
o = append(o, 0xa4, 0x78, 0x61, 0x69, 0x64)
if (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset == nil {
@@ -11860,11 +12615,11 @@ func (z *encodedSignedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset)))
}
- for zb0020 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- o = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].MarshalMsg(o)
+ for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ o = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x800) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x20000) == 0 { // if not empty
// string "xaidbm"
o = append(o, 0xa6, 0x78, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
@@ -11882,25 +12637,25 @@ func (_ *encodedSignedTxns) CanMarshalMsg(z interface{}) bool {
func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0049 int
- var zb0050 bool
- zb0049, zb0050, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0053 int
+ var zb0054 bool
+ zb0053, zb0054, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0049, zb0050, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0053, zb0054, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0049 > 0 {
- zb0049--
- var zb0051 int
- zb0051, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0055 int
+ zb0055, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Sig")
return
}
- if zb0051 > maxSignatureBytes {
- err = msgp.ErrOverflow(uint64(zb0051), uint64(maxSignatureBytes))
+ if zb0055 > maxSignatureBytes {
+ err = msgp.ErrOverflow(uint64(zb0055), uint64(maxSignatureBytes))
return
}
(*z).Sig, bts, err = msgp.ReadBytesBytes(bts, (*z).Sig)
@@ -11909,38 +12664,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0052 []byte
- var zb0053 int
- zb0053, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0056 []byte
+ var zb0057 int
+ zb0057, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSig")
return
}
- if zb0053 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0053), uint64(maxBitmaskSize))
+ if zb0057 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0057), uint64(maxBitmaskSize))
return
}
- zb0052, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSig))
+ zb0056, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSig))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSig")
return
}
- (*z).BitmaskSig = bitmask(zb0052)
+ (*z).BitmaskSig = bitmask(zb0056)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0054 int
- zb0054, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0058 int
+ zb0058, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Version")
return
}
- if zb0054 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0054), uint64(maxEncodedTransactionGroups))
+ if zb0058 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0058), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedMsigs.Version, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedMsigs.Version)
@@ -11949,38 +12704,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0055 []byte
- var zb0056 int
- zb0056, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0059 []byte
+ var zb0060 int
+ zb0060, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVersion")
return
}
- if zb0056 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0056), uint64(maxBitmaskSize))
+ if zb0060 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0060), uint64(maxBitmaskSize))
return
}
- zb0055, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskVersion))
+ zb0059, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskVersion))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVersion")
return
}
- (*z).encodedMsigs.BitmaskVersion = bitmask(zb0055)
+ (*z).encodedMsigs.BitmaskVersion = bitmask(zb0059)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0057 int
- zb0057, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0061 int
+ zb0061, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Threshold")
return
}
- if zb0057 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0057), uint64(maxEncodedTransactionGroups))
+ if zb0061 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0061), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedMsigs.Threshold, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedMsigs.Threshold)
@@ -11989,68 +12744,68 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0058 []byte
- var zb0059 int
- zb0059, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0062 []byte
+ var zb0063 int
+ zb0063, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskThreshold")
return
}
- if zb0059 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0059), uint64(maxBitmaskSize))
+ if zb0063 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0063), uint64(maxBitmaskSize))
return
}
- zb0058, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskThreshold))
+ zb0062, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskThreshold))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskThreshold")
return
}
- (*z).encodedMsigs.BitmaskThreshold = bitmask(zb0058)
+ (*z).encodedMsigs.BitmaskThreshold = bitmask(zb0062)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0060 int
- var zb0061 bool
- zb0060, zb0061, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0064 int
+ var zb0065 bool
+ zb0064, zb0065, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Subsigs")
return
}
- if zb0060 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0060), uint64(maxEncodedTransactionGroups))
+ if zb0064 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0064), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Subsigs")
return
}
- if zb0061 {
+ if zb0065 {
(*z).encodedMsigs.Subsigs = nil
- } else if (*z).encodedMsigs.Subsigs != nil && cap((*z).encodedMsigs.Subsigs) >= zb0060 {
- (*z).encodedMsigs.Subsigs = ((*z).encodedMsigs.Subsigs)[:zb0060]
+ } else if (*z).encodedMsigs.Subsigs != nil && cap((*z).encodedMsigs.Subsigs) >= zb0064 {
+ (*z).encodedMsigs.Subsigs = ((*z).encodedMsigs.Subsigs)[:zb0064]
} else {
- (*z).encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0060)
+ (*z).encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0064)
}
for zb0001 := range (*z).encodedMsigs.Subsigs {
- var zb0062 int
- var zb0063 bool
- zb0062, zb0063, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0066 int
+ var zb0067 bool
+ zb0066, zb0067, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Subsigs", zb0001)
return
}
- if zb0062 > crypto.MaxMultisig {
- err = msgp.ErrOverflow(uint64(zb0062), uint64(crypto.MaxMultisig))
+ if zb0066 > crypto.MaxMultisig {
+ err = msgp.ErrOverflow(uint64(zb0066), uint64(crypto.MaxMultisig))
err = msgp.WrapError(err, "struct-from-array", "Subsigs", zb0001)
return
}
- if zb0063 {
+ if zb0067 {
(*z).encodedMsigs.Subsigs[zb0001] = nil
- } else if (*z).encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedMsigs.Subsigs[zb0001]) >= zb0062 {
- (*z).encodedMsigs.Subsigs[zb0001] = ((*z).encodedMsigs.Subsigs[zb0001])[:zb0062]
+ } else if (*z).encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedMsigs.Subsigs[zb0001]) >= zb0066 {
+ (*z).encodedMsigs.Subsigs[zb0001] = ((*z).encodedMsigs.Subsigs[zb0001])[:zb0066]
} else {
- (*z).encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0062)
+ (*z).encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0066)
}
for zb0002 := range (*z).encodedMsigs.Subsigs[zb0001] {
bts, err = (*z).encodedMsigs.Subsigs[zb0001][zb0002].UnmarshalMsg(bts)
@@ -12061,58 +12816,58 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0064 []byte
- var zb0065 int
- zb0065, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0068 []byte
+ var zb0069 int
+ zb0069, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSubsigs")
return
}
- if zb0065 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0065), uint64(maxBitmaskSize))
+ if zb0069 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0069), uint64(maxBitmaskSize))
return
}
- zb0064, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskSubsigs))
+ zb0068, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskSubsigs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSubsigs")
return
}
- (*z).encodedMsigs.BitmaskSubsigs = bitmask(zb0064)
+ (*z).encodedMsigs.BitmaskSubsigs = bitmask(zb0068)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0066 int
- var zb0067 bool
- zb0066, zb0067, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0070 int
+ var zb0071 bool
+ zb0070, zb0071, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Logic")
return
}
- if zb0066 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0066), uint64(maxEncodedTransactionGroups))
+ if zb0070 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0070), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Logic")
return
}
- if zb0067 {
+ if zb0071 {
(*z).encodedLsigs.Logic = nil
- } else if (*z).encodedLsigs.Logic != nil && cap((*z).encodedLsigs.Logic) >= zb0066 {
- (*z).encodedLsigs.Logic = ((*z).encodedLsigs.Logic)[:zb0066]
+ } else if (*z).encodedLsigs.Logic != nil && cap((*z).encodedLsigs.Logic) >= zb0070 {
+ (*z).encodedLsigs.Logic = ((*z).encodedLsigs.Logic)[:zb0070]
} else {
- (*z).encodedLsigs.Logic = make([][]byte, zb0066)
+ (*z).encodedLsigs.Logic = make([][]byte, zb0070)
}
for zb0003 := range (*z).encodedLsigs.Logic {
- var zb0068 int
- zb0068, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0072 int
+ zb0072, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Logic", zb0003)
return
}
- if zb0068 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0068), uint64(config.MaxLogicSigMaxSize))
+ if zb0072 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0072), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedLsigs.Logic[zb0003], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedLsigs.Logic[zb0003])
@@ -12122,78 +12877,78 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0069 []byte
- var zb0070 int
- zb0070, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0073 []byte
+ var zb0074 int
+ zb0074, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogic")
return
}
- if zb0070 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0070), uint64(maxBitmaskSize))
+ if zb0074 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0074), uint64(maxBitmaskSize))
return
}
- zb0069, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogic))
+ zb0073, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogic))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogic")
return
}
- (*z).encodedLsigs.BitmaskLogic = bitmask(zb0069)
+ (*z).encodedLsigs.BitmaskLogic = bitmask(zb0073)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0071 int
- var zb0072 bool
- zb0071, zb0072, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0075 int
+ var zb0076 bool
+ zb0075, zb0076, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs")
return
}
- if zb0071 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0071), uint64(maxEncodedTransactionGroups))
+ if zb0075 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0075), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LogicArgs")
return
}
- if zb0072 {
+ if zb0076 {
(*z).encodedLsigs.LogicArgs = nil
- } else if (*z).encodedLsigs.LogicArgs != nil && cap((*z).encodedLsigs.LogicArgs) >= zb0071 {
- (*z).encodedLsigs.LogicArgs = ((*z).encodedLsigs.LogicArgs)[:zb0071]
+ } else if (*z).encodedLsigs.LogicArgs != nil && cap((*z).encodedLsigs.LogicArgs) >= zb0075 {
+ (*z).encodedLsigs.LogicArgs = ((*z).encodedLsigs.LogicArgs)[:zb0075]
} else {
- (*z).encodedLsigs.LogicArgs = make([][][]byte, zb0071)
+ (*z).encodedLsigs.LogicArgs = make([][][]byte, zb0075)
}
for zb0004 := range (*z).encodedLsigs.LogicArgs {
- var zb0073 int
- var zb0074 bool
- zb0073, zb0074, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0077 int
+ var zb0078 bool
+ zb0077, zb0078, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004)
return
}
- if zb0073 > transactions.EvalMaxArgs {
- err = msgp.ErrOverflow(uint64(zb0073), uint64(transactions.EvalMaxArgs))
+ if zb0077 > transactions.EvalMaxArgs {
+ err = msgp.ErrOverflow(uint64(zb0077), uint64(transactions.EvalMaxArgs))
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004)
return
}
- if zb0074 {
+ if zb0078 {
(*z).encodedLsigs.LogicArgs[zb0004] = nil
- } else if (*z).encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedLsigs.LogicArgs[zb0004]) >= zb0073 {
- (*z).encodedLsigs.LogicArgs[zb0004] = ((*z).encodedLsigs.LogicArgs[zb0004])[:zb0073]
+ } else if (*z).encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedLsigs.LogicArgs[zb0004]) >= zb0077 {
+ (*z).encodedLsigs.LogicArgs[zb0004] = ((*z).encodedLsigs.LogicArgs[zb0004])[:zb0077]
} else {
- (*z).encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0073)
+ (*z).encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0077)
}
for zb0005 := range (*z).encodedLsigs.LogicArgs[zb0004] {
- var zb0075 int
- zb0075, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0079 int
+ zb0079, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004, zb0005)
return
}
- if zb0075 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0075), uint64(config.MaxLogicSigMaxSize))
+ if zb0079 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0079), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedLsigs.LogicArgs[zb0004][zb0005], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedLsigs.LogicArgs[zb0004][zb0005])
@@ -12204,38 +12959,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0076 []byte
- var zb0077 int
- zb0077, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0080 []byte
+ var zb0081 int
+ zb0081, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogicArgs")
return
}
- if zb0077 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0077), uint64(maxBitmaskSize))
+ if zb0081 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0081), uint64(maxBitmaskSize))
return
}
- zb0076, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogicArgs))
+ zb0080, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogicArgs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogicArgs")
return
}
- (*z).encodedLsigs.BitmaskLogicArgs = bitmask(zb0076)
+ (*z).encodedLsigs.BitmaskLogicArgs = bitmask(zb0080)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0078 int
- zb0078, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0082 int
+ zb0082, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AuthAddr")
return
}
- if zb0078 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0078), uint64(maxAddressBytes))
+ if zb0082 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0082), uint64(maxAddressBytes))
return
}
(*z).AuthAddr, bts, err = msgp.ReadBytesBytes(bts, (*z).AuthAddr)
@@ -12244,38 +12999,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0079 []byte
- var zb0080 int
- zb0080, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0083 []byte
+ var zb0084 int
+ zb0084, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAuthAddr")
return
}
- if zb0080 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0080), uint64(maxBitmaskSize))
+ if zb0084 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0084), uint64(maxBitmaskSize))
return
}
- zb0079, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskAuthAddr))
+ zb0083, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskAuthAddr))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAuthAddr")
return
}
- (*z).BitmaskAuthAddr = bitmask(zb0079)
+ (*z).BitmaskAuthAddr = bitmask(zb0083)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0081 int
- zb0081, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0085 int
+ zb0085, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxType")
return
}
- if zb0081 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0081), uint64(maxEncodedTransactionGroups))
+ if zb0085 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0085), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedTxns.TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.TxType)
@@ -12284,46 +13039,46 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0082 []byte
- var zb0083 int
- zb0083, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0086 []byte
+ var zb0087 int
+ zb0087, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- if zb0083 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0083), uint64(maxBitmaskSize))
+ if zb0087 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0087), uint64(maxBitmaskSize))
return
}
- zb0082, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.BitmaskTxType))
+ zb0086, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- (*z).encodedTxns.BitmaskTxType = bitmask(zb0082)
+ (*z).encodedTxns.BitmaskTxType = bitmask(zb0086)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
(*z).encodedTxns.TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxTypeOffset")
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0084 int
- zb0084, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0088 int
+ zb0088, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Sender")
return
}
- if zb0084 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0084), uint64(maxAddressBytes))
+ if zb0088 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0088), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Sender)
@@ -12332,48 +13087,48 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0085 []byte
- var zb0086 int
- zb0086, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0089 []byte
+ var zb0090 int
+ zb0090, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- if zb0086 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0086), uint64(maxBitmaskSize))
+ if zb0090 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0090), uint64(maxBitmaskSize))
return
}
- zb0085, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskSender))
+ zb0089, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0085)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0089)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0087 int
- var zb0088 bool
- zb0087, zb0088, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0091 int
+ var zb0092 bool
+ zb0091, zb0092, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0087 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0087), uint64(maxEncodedTransactionGroups))
+ if zb0091 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0091), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0088 {
+ if zb0092 {
(*z).encodedTxns.encodedTxnHeaders.Fee = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedTxns.encodedTxnHeaders.Fee) >= zb0087 {
- (*z).encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedTxns.encodedTxnHeaders.Fee)[:zb0087]
+ } else if (*z).encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedTxns.encodedTxnHeaders.Fee) >= zb0091 {
+ (*z).encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedTxns.encodedTxnHeaders.Fee)[:zb0091]
} else {
- (*z).encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0087)
+ (*z).encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0091)
}
for zb0006 := range (*z).encodedTxns.encodedTxnHeaders.Fee {
bts, err = (*z).encodedTxns.encodedTxnHeaders.Fee[zb0006].UnmarshalMsg(bts)
@@ -12383,48 +13138,48 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0089 []byte
- var zb0090 int
- zb0090, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0093 []byte
+ var zb0094 int
+ zb0094, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- if zb0090 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0090), uint64(maxBitmaskSize))
+ if zb0094 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0094), uint64(maxBitmaskSize))
return
}
- zb0089, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFee))
+ zb0093, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0089)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0093)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0091 int
- var zb0092 bool
- zb0091, zb0092, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0095 int
+ var zb0096 bool
+ zb0095, zb0096, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0091 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0091), uint64(maxEncodedTransactionGroups))
+ if zb0095 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0095), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0092 {
+ if zb0096 {
(*z).encodedTxns.encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.FirstValid) >= zb0091 {
- (*z).encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedTxns.encodedTxnHeaders.FirstValid)[:zb0091]
+ } else if (*z).encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.FirstValid) >= zb0095 {
+ (*z).encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedTxns.encodedTxnHeaders.FirstValid)[:zb0095]
} else {
- (*z).encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0091)
+ (*z).encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0095)
}
for zb0007 := range (*z).encodedTxns.encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedTxns.encodedTxnHeaders.FirstValid[zb0007].UnmarshalMsg(bts)
@@ -12434,48 +13189,48 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0093 []byte
- var zb0094 int
- zb0094, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0097 []byte
+ var zb0098 int
+ zb0098, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- if zb0094 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0094), uint64(maxBitmaskSize))
+ if zb0098 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0098), uint64(maxBitmaskSize))
return
}
- zb0093, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
+ zb0097, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0093)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0097)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0095 int
- var zb0096 bool
- zb0095, zb0096, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0099 int
+ var zb0100 bool
+ zb0099, zb0100, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0095 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0095), uint64(maxEncodedTransactionGroups))
+ if zb0099 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0099), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0096 {
+ if zb0100 {
(*z).encodedTxns.encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.LastValid) >= zb0095 {
- (*z).encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedTxns.encodedTxnHeaders.LastValid)[:zb0095]
+ } else if (*z).encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.LastValid) >= zb0099 {
+ (*z).encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedTxns.encodedTxnHeaders.LastValid)[:zb0099]
} else {
- (*z).encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0095)
+ (*z).encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0099)
}
for zb0008 := range (*z).encodedTxns.encodedTxnHeaders.LastValid {
bts, err = (*z).encodedTxns.encodedTxnHeaders.LastValid[zb0008].UnmarshalMsg(bts)
@@ -12485,58 +13240,58 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0097 []byte
- var zb0098 int
- zb0098, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0101 []byte
+ var zb0102 int
+ zb0102, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- if zb0098 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0098), uint64(maxBitmaskSize))
+ if zb0102 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0102), uint64(maxBitmaskSize))
return
}
- zb0097, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid))
+ zb0101, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0097)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0101)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0099 int
- var zb0100 bool
- zb0099, zb0100, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0103 int
+ var zb0104 bool
+ zb0103, zb0104, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0099 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0099), uint64(maxEncodedTransactionGroups))
+ if zb0103 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0103), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0100 {
+ if zb0104 {
(*z).encodedTxns.encodedTxnHeaders.Note = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedTxns.encodedTxnHeaders.Note) >= zb0099 {
- (*z).encodedTxns.encodedTxnHeaders.Note = ((*z).encodedTxns.encodedTxnHeaders.Note)[:zb0099]
+ } else if (*z).encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedTxns.encodedTxnHeaders.Note) >= zb0103 {
+ (*z).encodedTxns.encodedTxnHeaders.Note = ((*z).encodedTxns.encodedTxnHeaders.Note)[:zb0103]
} else {
- (*z).encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0099)
+ (*z).encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0103)
}
for zb0009 := range (*z).encodedTxns.encodedTxnHeaders.Note {
- var zb0101 int
- zb0101, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0105 int
+ zb0105, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note", zb0009)
return
}
- if zb0101 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0101), uint64(config.MaxTxnNoteBytes))
+ if zb0105 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0105), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Note[zb0009], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Note[zb0009])
@@ -12546,82 +13301,82 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0102 []byte
- var zb0103 int
- zb0103, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0106 []byte
+ var zb0107 int
+ zb0107, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- if zb0103 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0103), uint64(maxBitmaskSize))
+ if zb0107 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0107), uint64(maxBitmaskSize))
return
}
- zb0102, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskNote))
+ zb0106, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0102)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0106)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0104 []byte
- var zb0105 int
- zb0105, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0108 []byte
+ var zb0109 int
+ zb0109, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- if zb0105 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0105), uint64(maxBitmaskSize))
+ if zb0109 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0109), uint64(maxBitmaskSize))
return
}
- zb0104, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
+ zb0108, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0104)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0108)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0106 []byte
- var zb0107 int
- zb0107, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0110 []byte
+ var zb0111 int
+ zb0111, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- if zb0107 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0107), uint64(maxBitmaskSize))
+ if zb0111 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0111), uint64(maxBitmaskSize))
return
}
- zb0106, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup))
+ zb0110, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0106)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0110)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0108 int
- zb0108, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0112 int
+ zb0112, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Lease")
return
}
- if zb0108 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0108), uint64(maxAddressBytes))
+ if zb0112 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0112), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Lease)
@@ -12630,38 +13385,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0109 []byte
- var zb0110 int
- zb0110, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0113 []byte
+ var zb0114 int
+ zb0114, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- if zb0110 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0110), uint64(maxBitmaskSize))
+ if zb0114 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0114), uint64(maxBitmaskSize))
return
}
- zb0109, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLease))
+ zb0113, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0109)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0113)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0111 int
- zb0111, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0115 int
+ zb0115, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "RekeyTo")
return
}
- if zb0111 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0111), uint64(maxAddressBytes))
+ if zb0115 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0115), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.RekeyTo)
@@ -12670,38 +13425,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0112 []byte
- var zb0113 int
- zb0113, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0116 []byte
+ var zb0117 int
+ zb0117, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- if zb0113 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0113), uint64(maxBitmaskSize))
+ if zb0117 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0117), uint64(maxBitmaskSize))
return
}
- zb0112, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
+ zb0116, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0112)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0116)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0114 int
- zb0114, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0118 int
+ zb0118, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VotePK")
return
}
- if zb0114 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0114), uint64(maxAddressBytes))
+ if zb0118 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0118), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.VotePK)
@@ -12710,16 +13465,16 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0115 int
- zb0115, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0119 int
+ zb0119, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SelectionPK")
return
}
- if zb0115 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0115), uint64(maxAddressBytes))
+ if zb0119 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0119), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.SelectionPK)
@@ -12728,26 +13483,26 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0116 int
- var zb0117 bool
- zb0116, zb0117, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0120 int
+ var zb0121 bool
+ zb0120, zb0121, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0116 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0116), uint64(maxEncodedTransactionGroups))
+ if zb0120 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0120), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0117 {
+ if zb0121 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0116 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0116]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0120 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0120]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0116)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0120)
}
for zb0010 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].UnmarshalMsg(bts)
@@ -12757,48 +13512,48 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0118 []byte
- var zb0119 int
- zb0119, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0122 []byte
+ var zb0123 int
+ zb0123, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- if zb0119 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0119), uint64(maxBitmaskSize))
+ if zb0123 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0123), uint64(maxBitmaskSize))
return
}
- zb0118, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0122, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0118)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0122)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0120 int
- var zb0121 bool
- zb0120, zb0121, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0124 int
+ var zb0125 bool
+ zb0124, zb0125, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0120 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0120), uint64(maxEncodedTransactionGroups))
+ if zb0124 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0124), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0121 {
+ if zb0125 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0120 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0120]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0124 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0124]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0120)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0124)
}
for zb0011 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].UnmarshalMsg(bts)
@@ -12808,48 +13563,48 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0122 []byte
- var zb0123 int
- zb0123, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0126 []byte
+ var zb0127 int
+ zb0127, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- if zb0123 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0123), uint64(maxBitmaskSize))
+ if zb0127 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0127), uint64(maxBitmaskSize))
return
}
- zb0122, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0126, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0122)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0126)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0124 int
- var zb0125 bool
- zb0124, zb0125, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0128 int
+ var zb0129 bool
+ zb0128, zb0129, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0124 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0124), uint64(maxEncodedTransactionGroups))
+ if zb0128 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0128), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0125 {
+ if zb0129 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0124 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0124]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0128 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0128]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0124)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0128)
}
for zb0012 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012], bts, err = msgp.ReadUint64Bytes(bts)
@@ -12859,60 +13614,107 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0126 []byte
- var zb0127 int
- zb0127, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0130 []byte
+ var zb0131 int
+ zb0131, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- if zb0127 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0127), uint64(maxBitmaskSize))
+ if zb0131 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0131), uint64(maxBitmaskSize))
return
}
- zb0126, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
+ zb0130, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0126)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0130)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0128 []byte
- var zb0129 int
- zb0129, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0132 []byte
+ var zb0133 int
+ zb0133, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- if zb0129 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0129), uint64(maxBitmaskSize))
+ if zb0133 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0133), uint64(maxBitmaskSize))
return
}
- zb0128, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0132, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0128)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0132)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0130 int
- zb0130, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0134 int
+ var zb0135 bool
+ zb0134, zb0135, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0134 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0134), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0135 {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot) >= zb0134 {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = ((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot)[:zb0134]
+ } else {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0134)
+ }
+ for zb0013 := range (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot", zb0013)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0136 int
+ zb0136, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ if zb0136 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0136), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0137 int
+ zb0137, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Receiver")
return
}
- if zb0130 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0130), uint64(maxAddressBytes))
+ if zb0137 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0137), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedPaymentTxnFields.Receiver)
@@ -12921,89 +13723,89 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0131 []byte
- var zb0132 int
- zb0132, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0138 []byte
+ var zb0139 int
+ zb0139, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- if zb0132 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0132), uint64(maxBitmaskSize))
+ if zb0139 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0139), uint64(maxBitmaskSize))
return
}
- zb0131, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
+ zb0138, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0131)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0138)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0133 int
- var zb0134 bool
- zb0133, zb0134, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0140 int
+ var zb0141 bool
+ zb0140, zb0141, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0133 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0133), uint64(maxEncodedTransactionGroups))
+ if zb0140 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0140), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0134 {
+ if zb0141 {
(*z).encodedTxns.encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedTxns.encodedPaymentTxnFields.Amount) >= zb0133 {
- (*z).encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedTxns.encodedPaymentTxnFields.Amount)[:zb0133]
+ } else if (*z).encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedTxns.encodedPaymentTxnFields.Amount) >= zb0140 {
+ (*z).encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedTxns.encodedPaymentTxnFields.Amount)[:zb0140]
} else {
- (*z).encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0133)
+ (*z).encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0140)
}
- for zb0013 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0013].UnmarshalMsg(bts)
+ for zb0014 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0014].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Amount", zb0013)
+ err = msgp.WrapError(err, "struct-from-array", "Amount", zb0014)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0135 []byte
- var zb0136 int
- zb0136, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0142 []byte
+ var zb0143 int
+ zb0143, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- if zb0136 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0136), uint64(maxBitmaskSize))
+ if zb0143 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0143), uint64(maxBitmaskSize))
return
}
- zb0135, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
+ zb0142, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0135)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0142)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0137 int
- zb0137, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0144 int
+ zb0144, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CloseRemainderTo")
return
}
- if zb0137 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0137), uint64(maxAddressBytes))
+ if zb0144 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0144), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
@@ -13012,366 +13814,366 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0138 []byte
- var zb0139 int
- zb0139, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0145 []byte
+ var zb0146 int
+ zb0146, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- if zb0139 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0139), uint64(maxBitmaskSize))
+ if zb0146 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0146), uint64(maxBitmaskSize))
return
}
- zb0138, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0145, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0138)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0145)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0140 int
- var zb0141 bool
- zb0140, zb0141, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0147 int
+ var zb0148 bool
+ zb0147, zb0148, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0140 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0140), uint64(maxEncodedTransactionGroups))
+ if zb0147 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0147), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0141 {
+ if zb0148 {
(*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0140 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0140]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0147 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0147]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0140)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0147)
}
- for zb0014 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].UnmarshalMsg(bts)
+ for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0014)
+ err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0015)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0142 []byte
- var zb0143 int
- zb0143, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0149 []byte
+ var zb0150 int
+ zb0150, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- if zb0143 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0143), uint64(maxBitmaskSize))
+ if zb0150 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0150), uint64(maxBitmaskSize))
return
}
- zb0142, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0149, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0142)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0149)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0144 int
- var zb0145 bool
- zb0144, zb0145, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0151 int
+ var zb0152 bool
+ zb0151, zb0152, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0144 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0144), uint64(maxEncodedTransactionGroups))
+ if zb0151 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0151), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0145 {
+ if zb0152 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0144 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0144]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0151 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0151]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0144)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0151)
}
- for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Total", zb0015)
+ err = msgp.WrapError(err, "struct-from-array", "Total", zb0016)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0146 []byte
- var zb0147 int
- zb0147, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0153 []byte
+ var zb0154 int
+ zb0154, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- if zb0147 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0147), uint64(maxBitmaskSize))
+ if zb0154 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0154), uint64(maxBitmaskSize))
return
}
- zb0146, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0153, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0146)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0153)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0148 int
- var zb0149 bool
- zb0148, zb0149, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0155 int
+ var zb0156 bool
+ zb0155, zb0156, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0148 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0148), uint64(maxEncodedTransactionGroups))
+ if zb0155 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0155), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0149 {
+ if zb0156 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0148 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0148]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0155 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0155]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0148)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0155)
}
- for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0016)
+ err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0017)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0150 []byte
- var zb0151 int
- zb0151, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0157 []byte
+ var zb0158 int
+ zb0158, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- if zb0151 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0151), uint64(maxBitmaskSize))
+ if zb0158 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0158), uint64(maxBitmaskSize))
return
}
- zb0150, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0157, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0150)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0157)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0152 []byte
- var zb0153 int
- zb0153, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0159 []byte
+ var zb0160 int
+ zb0160, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- if zb0153 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0153), uint64(maxBitmaskSize))
+ if zb0160 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0160), uint64(maxBitmaskSize))
return
}
- zb0152, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0159, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0152)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0159)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0154 int
- var zb0155 bool
- zb0154, zb0155, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0161 int
+ var zb0162 bool
+ zb0161, zb0162, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0154 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0154), uint64(maxEncodedTransactionGroups))
+ if zb0161 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0161), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0155 {
+ if zb0162 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0154 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0154]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0161 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0161]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0154)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0161)
}
- for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017], bts, err = msgp.ReadStringBytes(bts)
+ for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0017)
+ err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0018)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0156 []byte
- var zb0157 int
- zb0157, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0163 []byte
+ var zb0164 int
+ zb0164, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- if zb0157 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0157), uint64(maxBitmaskSize))
+ if zb0164 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0164), uint64(maxBitmaskSize))
return
}
- zb0156, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0163, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0156)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0163)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0158 int
- var zb0159 bool
- zb0158, zb0159, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0165 int
+ var zb0166 bool
+ zb0165, zb0166, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0158 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0158), uint64(maxEncodedTransactionGroups))
+ if zb0165 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0165), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0159 {
+ if zb0166 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0158 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0158]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0165 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0165]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0158)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0165)
}
- for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018], bts, err = msgp.ReadStringBytes(bts)
+ for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0018)
+ err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0019)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0160 []byte
- var zb0161 int
- zb0161, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0167 []byte
+ var zb0168 int
+ zb0168, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- if zb0161 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0161), uint64(maxBitmaskSize))
+ if zb0168 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0168), uint64(maxBitmaskSize))
return
}
- zb0160, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0167, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0160)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0167)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0162 int
- var zb0163 bool
- zb0162, zb0163, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0169 int
+ var zb0170 bool
+ zb0169, zb0170, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0162 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0162), uint64(maxEncodedTransactionGroups))
+ if zb0169 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0169), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0163 {
+ if zb0170 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0162 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0162]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0169 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0169]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0162)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0169)
}
- for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019], bts, err = msgp.ReadStringBytes(bts)
+ for zb0020 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "URL", zb0019)
+ err = msgp.WrapError(err, "struct-from-array", "URL", zb0020)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0164 []byte
- var zb0165 int
- zb0165, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0171 []byte
+ var zb0172 int
+ zb0172, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- if zb0165 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0165), uint64(maxBitmaskSize))
+ if zb0172 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0172), uint64(maxBitmaskSize))
return
}
- zb0164, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0171, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0164)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0171)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0166 int
- zb0166, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0173 int
+ zb0173, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "MetadataHash")
return
}
- if zb0166 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0166), uint64(maxAddressBytes))
+ if zb0173 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0173), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -13380,38 +14182,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0167 []byte
- var zb0168 int
- zb0168, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0174 []byte
+ var zb0175 int
+ zb0175, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- if zb0168 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0168), uint64(maxBitmaskSize))
+ if zb0175 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0175), uint64(maxBitmaskSize))
return
}
- zb0167, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0174, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0167)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0174)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0169 int
- zb0169, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0176 int
+ zb0176, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Manager")
return
}
- if zb0169 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0169), uint64(maxAddressBytes))
+ if zb0176 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0176), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -13420,38 +14222,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0170 []byte
- var zb0171 int
- zb0171, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0177 []byte
+ var zb0178 int
+ zb0178, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- if zb0171 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0171), uint64(maxBitmaskSize))
+ if zb0178 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0178), uint64(maxBitmaskSize))
return
}
- zb0170, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0177, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0170)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0177)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0172 int
- zb0172, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0179 int
+ zb0179, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reserve")
return
}
- if zb0172 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0172), uint64(maxAddressBytes))
+ if zb0179 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0179), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -13460,38 +14262,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0173 []byte
- var zb0174 int
- zb0174, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0180 []byte
+ var zb0181 int
+ zb0181, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- if zb0174 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0174), uint64(maxBitmaskSize))
+ if zb0181 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0181), uint64(maxBitmaskSize))
return
}
- zb0173, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0180, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0173)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0180)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0175 int
- zb0175, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0182 int
+ zb0182, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Freeze")
return
}
- if zb0175 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0175), uint64(maxAddressBytes))
+ if zb0182 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0182), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -13500,38 +14302,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0176 []byte
- var zb0177 int
- zb0177, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0183 []byte
+ var zb0184 int
+ zb0184, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- if zb0177 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0177), uint64(maxBitmaskSize))
+ if zb0184 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0184), uint64(maxBitmaskSize))
return
}
- zb0176, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0183, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0176)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0183)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0178 int
- zb0178, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0185 int
+ zb0185, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Clawback")
return
}
- if zb0178 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0178), uint64(maxAddressBytes))
+ if zb0185 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0185), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -13540,140 +14342,140 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0179 []byte
- var zb0180 int
- zb0180, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0186 []byte
+ var zb0187 int
+ zb0187, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- if zb0180 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0180), uint64(maxBitmaskSize))
+ if zb0187 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0187), uint64(maxBitmaskSize))
return
}
- zb0179, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0186, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0179)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0186)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0181 int
- var zb0182 bool
- zb0181, zb0182, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0188 int
+ var zb0189 bool
+ zb0188, zb0189, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0181 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0181), uint64(maxEncodedTransactionGroups))
+ if zb0188 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0188), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0182 {
+ if zb0189 {
(*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0181 {
- (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0181]
+ } else if (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0188 {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0188]
} else {
- (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0181)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0188)
}
- for zb0020 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].UnmarshalMsg(bts)
+ for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0020)
+ err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0021)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0183 []byte
- var zb0184 int
- zb0184, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0190 []byte
+ var zb0191 int
+ zb0191, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- if zb0184 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0184), uint64(maxBitmaskSize))
+ if zb0191 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0191), uint64(maxBitmaskSize))
return
}
- zb0183, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0190, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0183)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0190)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0185 int
- var zb0186 bool
- zb0185, zb0186, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0192 int
+ var zb0193 bool
+ zb0192, zb0193, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0185 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0185), uint64(maxEncodedTransactionGroups))
+ if zb0192 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0192), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0186 {
+ if zb0193 {
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0185 {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0185]
+ } else if (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0192 {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0192]
} else {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0185)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0192)
}
- for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0022 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0021)
+ err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0022)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0187 []byte
- var zb0188 int
- zb0188, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0194 []byte
+ var zb0195 int
+ zb0195, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- if zb0188 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0188), uint64(maxBitmaskSize))
+ if zb0195 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0195), uint64(maxBitmaskSize))
return
}
- zb0187, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0194, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0187)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0194)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0189 int
- zb0189, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0196 int
+ zb0196, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetSender")
return
}
- if zb0189 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0189), uint64(maxAddressBytes))
+ if zb0196 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0196), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender)
@@ -13682,38 +14484,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0190 []byte
- var zb0191 int
- zb0191, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0197 []byte
+ var zb0198 int
+ zb0198, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- if zb0191 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0191), uint64(maxBitmaskSize))
+ if zb0198 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0198), uint64(maxBitmaskSize))
return
}
- zb0190, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0197, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0190)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0197)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0192 int
- zb0192, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0199 int
+ zb0199, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetReceiver")
return
}
- if zb0192 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0192), uint64(maxAddressBytes))
+ if zb0199 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0199), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
@@ -13722,38 +14524,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0193 []byte
- var zb0194 int
- zb0194, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0200 []byte
+ var zb0201 int
+ zb0201, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- if zb0194 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0194), uint64(maxBitmaskSize))
+ if zb0201 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0201), uint64(maxBitmaskSize))
return
}
- zb0193, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0200, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0193)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0200)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0195 int
- zb0195, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0202 int
+ zb0202, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetCloseTo")
return
}
- if zb0195 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0195), uint64(maxAddressBytes))
+ if zb0202 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0202), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
@@ -13762,38 +14564,38 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0196 []byte
- var zb0197 int
- zb0197, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0203 []byte
+ var zb0204 int
+ zb0204, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- if zb0197 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0197), uint64(maxBitmaskSize))
+ if zb0204 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0204), uint64(maxBitmaskSize))
return
}
- zb0196, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0203, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0196)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0203)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0198 int
- zb0198, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0205 int
+ zb0205, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAccount")
return
}
- if zb0198 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0198), uint64(maxAddressBytes))
+ if zb0205 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0205), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
@@ -13802,162 +14604,162 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0199 []byte
- var zb0200 int
- zb0200, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0206 []byte
+ var zb0207 int
+ zb0207, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- if zb0200 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0200), uint64(maxBitmaskSize))
+ if zb0207 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0207), uint64(maxBitmaskSize))
return
}
- zb0199, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0206, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0199)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0206)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0201 int
- var zb0202 bool
- zb0201, zb0202, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0208 int
+ var zb0209 bool
+ zb0208, zb0209, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0201 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0201), uint64(maxEncodedTransactionGroups))
+ if zb0208 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0208), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0202 {
+ if zb0209 {
(*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0201 {
- (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0201]
+ } else if (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0208 {
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0208]
} else {
- (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0201)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0208)
}
- for zb0022 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0022)
+ err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0023)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0203 []byte
- var zb0204 int
- zb0204, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0210 []byte
+ var zb0211 int
+ zb0211, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- if zb0204 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0204), uint64(maxBitmaskSize))
+ if zb0211 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0211), uint64(maxBitmaskSize))
return
}
- zb0203, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0210, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0203)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0210)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0205 []byte
- var zb0206 int
- zb0206, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0212 []byte
+ var zb0213 int
+ zb0213, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- if zb0206 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0206), uint64(maxBitmaskSize))
+ if zb0213 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0213), uint64(maxBitmaskSize))
return
}
- zb0205, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0212, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0205)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0212)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0207 int
- var zb0208 bool
- zb0207, zb0208, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0214 int
+ var zb0215 bool
+ zb0214, zb0215, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0207 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0207), uint64(maxEncodedTransactionGroups))
+ if zb0214 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0214), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0208 {
+ if zb0215 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0207 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0207]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0214 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0214]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0207)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0214)
}
- for zb0023 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].UnmarshalMsg(bts)
+ for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0023)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0024)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0209 []byte
- var zb0210 int
- zb0210, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0216 []byte
+ var zb0217 int
+ zb0217, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- if zb0210 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0210), uint64(maxBitmaskSize))
+ if zb0217 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0217), uint64(maxBitmaskSize))
return
}
- zb0209, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0216, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0209)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0216)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0211 int
- zb0211, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0218 int
+ zb0218, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "OnCompletion")
return
}
- if zb0211 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0211), uint64(maxEncodedTransactionGroups))
+ if zb0218 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0218), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
@@ -13966,1119 +14768,1232 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0212 []byte
- var zb0213 int
- zb0213, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0219 []byte
+ var zb0220 int
+ zb0220, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- if zb0213 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0213), uint64(maxBitmaskSize))
+ if zb0220 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0220), uint64(maxBitmaskSize))
return
}
- zb0212, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0219, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0212)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0219)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0214 int
- var zb0215 bool
- zb0214, zb0215, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0221 int
+ var zb0222 bool
+ zb0221, zb0222, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0214 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0214), uint64(maxEncodedTransactionGroups))
+ if zb0221 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0221), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0215 {
+ if zb0222 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0214 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0214]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0221 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0221]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0214)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0221)
}
- for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0216 int
- var zb0217 bool
- zb0216, zb0217, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0223 int
+ var zb0224 bool
+ zb0223, zb0224, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025)
return
}
- if zb0216 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0216), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024)
+ if zb0223 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0223), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025)
return
}
- if zb0217 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024]) >= zb0216 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])[:zb0216]
+ if zb0224 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025]) >= zb0223 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])[:zb0223]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = make(applicationArgs, zb0216)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = make(applicationArgs, zb0223)
}
- for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024, zb0025)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025, zb0026)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0218 []byte
- var zb0219 int
- zb0219, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0225 []byte
+ var zb0226 int
+ zb0226, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- if zb0219 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0219), uint64(maxBitmaskSize))
+ if zb0226 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0226), uint64(maxBitmaskSize))
return
}
- zb0218, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0225, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0218)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0225)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0220 int
- var zb0221 bool
- zb0220, zb0221, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0227 int
+ var zb0228 bool
+ zb0227, zb0228, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0220 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0220), uint64(maxEncodedTransactionGroups))
+ if zb0227 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0227), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0221 {
+ if zb0228 {
(*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0220 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0220]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0227 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0227]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0220)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0227)
}
- for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
- var zb0222 int
- var zb0223 bool
- zb0222, zb0223, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ var zb0229 int
+ var zb0230 bool
+ zb0229, zb0230, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027)
return
}
- if zb0222 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0222), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026)
+ if zb0229 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0229), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027)
return
}
- if zb0223 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026]) >= zb0222 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])[:zb0222]
+ if zb0230 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027]) >= zb0229 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])[:zb0229]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = make(addresses, zb0222)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = make(addresses, zb0229)
}
- for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].UnmarshalMsg(bts)
+ for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026, zb0027)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027, zb0028)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0224 []byte
- var zb0225 int
- zb0225, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0231 []byte
+ var zb0232 int
+ zb0232, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- if zb0225 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0225), uint64(maxBitmaskSize))
+ if zb0232 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0232), uint64(maxBitmaskSize))
return
}
- zb0224, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0231, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0224)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0231)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0226 int
- var zb0227 bool
- zb0226, zb0227, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0233 int
+ var zb0234 bool
+ zb0233, zb0234, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0226 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0226), uint64(maxEncodedTransactionGroups))
+ if zb0233 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0233), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0227 {
+ if zb0234 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0226 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0226]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0233 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0233]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0226)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0233)
}
- for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- var zb0228 int
- var zb0229 bool
- zb0228, zb0229, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ var zb0235 int
+ var zb0236 bool
+ zb0235, zb0236, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029)
return
}
- if zb0228 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0228), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028)
+ if zb0235 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0235), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029)
return
}
- if zb0229 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028]) >= zb0228 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])[:zb0228]
+ if zb0236 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029]) >= zb0235 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])[:zb0235]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = make(appIndices, zb0228)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = make(appIndices, zb0235)
}
- for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].UnmarshalMsg(bts)
+ for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028, zb0029)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029, zb0030)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0230 []byte
- var zb0231 int
- zb0231, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0237 []byte
+ var zb0238 int
+ zb0238, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- if zb0231 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0231), uint64(maxBitmaskSize))
+ if zb0238 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0238), uint64(maxBitmaskSize))
return
}
- zb0230, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0237, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0230)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0237)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0232 int
- var zb0233 bool
- zb0232, zb0233, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0239 int
+ var zb0240 bool
+ zb0239, zb0240, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0232 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0232), uint64(maxEncodedTransactionGroups))
+ if zb0239 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0239), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0233 {
+ if zb0240 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0232 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0232]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0239 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0239]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0232)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0239)
}
- for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- var zb0234 int
- var zb0235 bool
- zb0234, zb0235, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0241 int
+ var zb0242 bool
+ zb0241, zb0242, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031)
return
}
- if zb0234 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0234), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030)
+ if zb0241 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0241), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031)
return
}
- if zb0235 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030]) >= zb0234 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])[:zb0234]
+ if zb0242 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031]) >= zb0241 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])[:zb0241]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = make(assetIndices, zb0234)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = make(assetIndices, zb0241)
}
- for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].UnmarshalMsg(bts)
+ for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030, zb0031)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031, zb0032)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0236 []byte
- var zb0237 int
- zb0237, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0243 []byte
+ var zb0244 int
+ zb0244, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- if zb0237 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0237), uint64(maxBitmaskSize))
+ if zb0244 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0244), uint64(maxBitmaskSize))
return
}
- zb0236, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0243, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0236)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0243)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0238 int
- var zb0239 bool
- zb0238, zb0239, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0245 int
+ var zb0246 bool
+ zb0245, zb0246, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0238 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0238), uint64(maxEncodedTransactionGroups))
+ if zb0245 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0245), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0239 {
+ if zb0246 {
(*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0238 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0238]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0245 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0245]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0238)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0245)
}
- for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0032)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0033)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0240 []byte
- var zb0241 int
- zb0241, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0247 []byte
+ var zb0248 int
+ zb0248, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- if zb0241 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0241), uint64(maxBitmaskSize))
+ if zb0248 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0248), uint64(maxBitmaskSize))
return
}
- zb0240, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0247, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0240)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0247)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0242 int
- var zb0243 bool
- zb0242, zb0243, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0249 int
+ var zb0250 bool
+ zb0249, zb0250, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0242 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0242), uint64(maxEncodedTransactionGroups))
+ if zb0249 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0249), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0243 {
+ if zb0250 {
(*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0242 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0242]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0249 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0249]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0242)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0249)
}
- for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0033)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0034)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0244 []byte
- var zb0245 int
- zb0245, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0251 []byte
+ var zb0252 int
+ zb0252, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- if zb0245 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0245), uint64(maxBitmaskSize))
+ if zb0252 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0252), uint64(maxBitmaskSize))
return
}
- zb0244, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0251, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0244)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0251)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0246 int
- var zb0247 bool
- zb0246, zb0247, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0253 int
+ var zb0254 bool
+ zb0253, zb0254, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0246 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0246), uint64(maxEncodedTransactionGroups))
+ if zb0253 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0253), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0247 {
+ if zb0254 {
(*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0246 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0246]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0253 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0253]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0246)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0253)
}
- for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0034)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0035)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0248 []byte
- var zb0249 int
- zb0249, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0255 []byte
+ var zb0256 int
+ zb0256, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- if zb0249 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0249), uint64(maxBitmaskSize))
+ if zb0256 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0256), uint64(maxBitmaskSize))
return
}
- zb0248, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0255, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0248)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0255)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0250 int
- var zb0251 bool
- zb0250, zb0251, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0257 int
+ var zb0258 bool
+ zb0257, zb0258, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0250 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0250), uint64(maxEncodedTransactionGroups))
+ if zb0257 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0257), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0251 {
+ if zb0258 {
(*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0250 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0250]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0257 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0257]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0250)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0257)
}
- for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0035)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0036)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0252 []byte
- var zb0253 int
- zb0253, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0259 []byte
+ var zb0260 int
+ zb0260, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- if zb0253 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0253), uint64(maxBitmaskSize))
+ if zb0260 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0260), uint64(maxBitmaskSize))
return
}
- zb0252, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0259, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0252)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0259)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0254 int
- var zb0255 bool
- zb0254, zb0255, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0261 int
+ var zb0262 bool
+ zb0261, zb0262, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0254 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0254), uint64(maxEncodedTransactionGroups))
+ if zb0261 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0261), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0255 {
+ if zb0262 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0254 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0254]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0261 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0261]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0254)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0261)
}
- for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0256 []byte
- var zb0257 int
- zb0257, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0263 []byte
+ var zb0264 int
+ zb0264, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0037)
return
}
- if zb0257 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0257), uint64(config.MaxAvailableAppProgramLen))
+ if zb0264 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0264), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0256, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ zb0263, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0037)
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036] = program(zb0256)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037] = program(zb0263)
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0258 []byte
- var zb0259 int
- zb0259, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0265 []byte
+ var zb0266 int
+ zb0266, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- if zb0259 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0259), uint64(maxBitmaskSize))
+ if zb0266 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0266), uint64(maxBitmaskSize))
return
}
- zb0258, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0265, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0258)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0265)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0260 int
- var zb0261 bool
- zb0260, zb0261, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0267 int
+ var zb0268 bool
+ zb0267, zb0268, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0260 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0260), uint64(maxEncodedTransactionGroups))
+ if zb0267 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0267), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0261 {
+ if zb0268 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0260 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0260]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0267 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0267]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0260)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0267)
}
- for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0262 []byte
- var zb0263 int
- zb0263, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0269 []byte
+ var zb0270 int
+ zb0270, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0038)
return
}
- if zb0263 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0263), uint64(config.MaxAvailableAppProgramLen))
+ if zb0270 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0270), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0262, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ zb0269, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0038)
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037] = program(zb0262)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038] = program(zb0269)
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0264 []byte
- var zb0265 int
- zb0265, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0271 []byte
+ var zb0272 int
+ zb0272, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- if zb0265 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0265), uint64(maxBitmaskSize))
+ if zb0272 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0272), uint64(maxBitmaskSize))
return
}
- zb0264, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0271, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0264)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0271)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0266 int
- var zb0267 bool
- zb0266, zb0267, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0273 int
+ var zb0274 bool
+ zb0273, zb0274, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0266 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0266), uint64(maxEncodedTransactionGroups))
+ if zb0273 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0273), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0267 {
+ if zb0274 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0266 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0266]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0273 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0273]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0266)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0273)
}
- for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0039 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0038)
+ err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0039)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0268 []byte
- var zb0269 int
- zb0269, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0275 []byte
+ var zb0276 int
+ zb0276, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- if zb0269 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0269), uint64(maxBitmaskSize))
+ if zb0276 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0276), uint64(maxBitmaskSize))
return
}
- zb0268, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0275, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0268)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0275)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0270 int
- var zb0271 bool
- zb0270, zb0271, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0277 int
+ var zb0278 bool
+ zb0277, zb0278, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0270 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0270), uint64(maxEncodedTransactionGroups))
+ if zb0277 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0277), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0271 {
+ if zb0278 {
(*z).encodedTxns.encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0270 {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0270]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0277 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0277]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0270)
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0277)
}
- for zb0039 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0039)
+ err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0040)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0272 []byte
- var zb0273 int
- zb0273, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0279 []byte
+ var zb0280 int
+ zb0280, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- if zb0273 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0273), uint64(maxBitmaskSize))
+ if zb0280 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0280), uint64(maxBitmaskSize))
return
}
- zb0272, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0279, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0272)
+ (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0279)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0274 int
- var zb0275 bool
- zb0274, zb0275, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0281 int
+ var zb0282 bool
+ zb0281, zb0282, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0274 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0274), uint64(maxEncodedTransactionGroups))
+ if zb0281 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0281), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0275 {
+ if zb0282 {
(*z).encodedTxns.encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0274 {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0274]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0281 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0281]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0274)
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0281)
}
- for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].UnmarshalMsg(bts)
+ for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertType", zb0040)
+ err = msgp.WrapError(err, "struct-from-array", "CertType", zb0041)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0276 []byte
- var zb0277 int
- zb0277, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0283 []byte
+ var zb0284 int
+ zb0284, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- if zb0277 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0277), uint64(maxBitmaskSize))
+ if zb0284 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0284), uint64(maxBitmaskSize))
return
}
- zb0276, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
+ zb0283, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0276)
+ (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0283)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0278 int
- zb0278, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0285 int
+ var zb0286 bool
+ zb0285, zb0286, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
- if zb0278 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0278), uint64(maxAddressBytes))
- return
- }
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0285 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0285), uint64(maxAddressBytes))
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
+ if zb0286 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0285 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0285]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0285)
+ }
+ for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigCommit", zb0042)
+ return
+ }
+ }
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0279 []byte
- var zb0280 int
- zb0280, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0287 []byte
+ var zb0288 int
+ zb0288, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- if zb0280 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0280), uint64(maxBitmaskSize))
+ if zb0288 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0288), uint64(maxBitmaskSize))
return
}
- zb0279, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0287, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0279)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0287)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0281 int
- var zb0282 bool
- zb0281, zb0282, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0289 int
+ var zb0290 bool
+ zb0289, zb0290, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0281 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0281), uint64(maxEncodedTransactionGroups))
+ if zb0289 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0289), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0282 {
+ if zb0290 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0281 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0281]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0289 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0289]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0281)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0289)
}
- for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0041)
+ err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0043)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0283 []byte
- var zb0284 int
- zb0284, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0291 []byte
+ var zb0292 int
+ zb0292, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- if zb0284 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0284), uint64(maxBitmaskSize))
+ if zb0292 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0292), uint64(maxBitmaskSize))
return
}
- zb0283, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0291, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0283)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0291)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0285 int
- var zb0286 bool
- zb0285, zb0286, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0293 int
+ var zb0294 bool
+ zb0293, zb0294, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0285 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0285), uint64(maxEncodedTransactionGroups))
+ if zb0293 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0293), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0286 {
+ if zb0294 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0285 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0285]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0293 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0293]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0285)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0293)
}
- for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0287 int
- var zb0288 bool
- zb0287, zb0288, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0295 int
+ var zb0296 bool
+ zb0295, zb0296, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044)
return
}
- if zb0287 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0287), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042)
+ if zb0295 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0295), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044)
return
}
- if zb0288 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042]) >= zb0287 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])[:zb0287]
+ if zb0296 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044]) >= zb0295 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])[:zb0295]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = make(certProofs, zb0287)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = make(certProofs, zb0295)
}
- for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].UnmarshalMsg(bts)
+ for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042, zb0043)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044, zb0045)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0289 []byte
- var zb0290 int
- zb0290, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0297 []byte
+ var zb0298 int
+ zb0298, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- if zb0290 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0290), uint64(maxBitmaskSize))
+ if zb0298 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0298), uint64(maxBitmaskSize))
return
}
- zb0289, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0297, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0289)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0297)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0291 int
- var zb0292 bool
- zb0291, zb0292, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0299 int
+ var zb0300 bool
+ zb0299, zb0300, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0299 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0299), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0300 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0299 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0299]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0299)
+ }
+ for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes", zb0046)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ {
+ var zb0301 []byte
+ var zb0302 int
+ zb0302, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ if zb0302 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0302), uint64(maxBitmaskSize))
+ return
+ }
+ zb0301, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0301)
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0303 int
+ var zb0304 bool
+ zb0303, zb0304, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0291 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0291), uint64(maxEncodedTransactionGroups))
+ if zb0303 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0303), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0292 {
+ if zb0304 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0291 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0291]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0303 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0303]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0291)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0303)
}
- for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0293 int
- var zb0294 bool
- zb0293, zb0294, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0047 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0305 int
+ var zb0306 bool
+ zb0305, zb0306, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047)
return
}
- if zb0293 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0293), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044)
+ if zb0305 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0305), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047)
return
}
- if zb0294 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044]) >= zb0293 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])[:zb0293]
+ if zb0306 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047]) >= zb0305 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])[:zb0305]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = make(certProofs, zb0293)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = make(certProofs, zb0305)
}
- for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].UnmarshalMsg(bts)
+ for zb0048 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044, zb0045)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047, zb0048)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0295 []byte
- var zb0296 int
- zb0296, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0307 []byte
+ var zb0308 int
+ zb0308, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- if zb0296 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0296), uint64(maxBitmaskSize))
+ if zb0308 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0308), uint64(maxBitmaskSize))
return
}
- zb0295, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0307, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0295)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0307)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0297 int
- var zb0298 bool
- zb0297, zb0298, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0309 int
+ var zb0310 bool
+ zb0309, zb0310, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0309 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0309), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0310 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0309 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0309]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0309)
+ }
+ for zb0049 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes", zb0049)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ {
+ var zb0311 []byte
+ var zb0312 int
+ zb0312, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ if zb0312 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0312), uint64(maxBitmaskSize))
+ return
+ }
+ zb0311, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0311)
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0313 int
+ var zb0314 bool
+ zb0313, zb0314, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0297 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0297), uint64(maxEncodedTransactionGroups))
+ if zb0313 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0313), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0298 {
+ if zb0314 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0297 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0297]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0313 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0313]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0297)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0313)
}
- for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0299 int
- var zb0300 bool
- zb0299, zb0300, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0050 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0315 int
+ var zb0316 bool
+ zb0315, zb0316, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- if zb0299 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0299), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ if zb0315 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0315), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- if zb0300 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = make(revealMap, zb0299)
+ if zb0316 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = make(revealMap, zb0315)
}
- for zb0299 > 0 {
- var zb0047 uint64
- var zb0048 compactcert.Reveal
- zb0299--
- zb0047, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0315 > 0 {
+ var zb0051 uint64
+ var zb0052 compactcert.Reveal
+ zb0315--
+ zb0051, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- bts, err = zb0048.UnmarshalMsg(bts)
+ bts, err = zb0052.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046, zb0047)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050, zb0051)
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047] = zb0048
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051] = zb0052
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0301 []byte
- var zb0302 int
- zb0302, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0317 []byte
+ var zb0318 int
+ zb0318, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- if zb0302 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0302), uint64(maxBitmaskSize))
+ if zb0318 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0318), uint64(maxBitmaskSize))
return
}
- zb0301, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0317, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0301)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0317)
}
}
- if zb0049 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0049)
+ if zb0053 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0053)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -15089,11 +16004,11 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err)
return
}
- if zb0050 {
+ if zb0054 {
(*z) = encodedSignedTxns{}
}
- for zb0049 > 0 {
- zb0049--
+ for zb0053 > 0 {
+ zb0053--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -15101,14 +16016,14 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
switch string(field) {
case "sig":
- var zb0303 int
- zb0303, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0319 int
+ zb0319, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Sig")
return
}
- if zb0303 > maxSignatureBytes {
- err = msgp.ErrOverflow(uint64(zb0303), uint64(maxSignatureBytes))
+ if zb0319 > maxSignatureBytes {
+ err = msgp.ErrOverflow(uint64(zb0319), uint64(maxSignatureBytes))
return
}
(*z).Sig, bts, err = msgp.ReadBytesBytes(bts, (*z).Sig)
@@ -15118,33 +16033,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sigbm":
{
- var zb0304 []byte
- var zb0305 int
- zb0305, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0320 []byte
+ var zb0321 int
+ zb0321, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSig")
return
}
- if zb0305 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0305), uint64(maxBitmaskSize))
+ if zb0321 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0321), uint64(maxBitmaskSize))
return
}
- zb0304, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSig))
+ zb0320, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskSig))
if err != nil {
err = msgp.WrapError(err, "BitmaskSig")
return
}
- (*z).BitmaskSig = bitmask(zb0304)
+ (*z).BitmaskSig = bitmask(zb0320)
}
case "msigv":
- var zb0306 int
- zb0306, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0322 int
+ zb0322, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Version")
return
}
- if zb0306 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0306), uint64(maxEncodedTransactionGroups))
+ if zb0322 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0322), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedMsigs.Version, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedMsigs.Version)
@@ -15154,33 +16069,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "msigvbm":
{
- var zb0307 []byte
- var zb0308 int
- zb0308, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0323 []byte
+ var zb0324 int
+ zb0324, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVersion")
return
}
- if zb0308 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0308), uint64(maxBitmaskSize))
+ if zb0324 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0324), uint64(maxBitmaskSize))
return
}
- zb0307, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskVersion))
+ zb0323, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskVersion))
if err != nil {
err = msgp.WrapError(err, "BitmaskVersion")
return
}
- (*z).encodedMsigs.BitmaskVersion = bitmask(zb0307)
+ (*z).encodedMsigs.BitmaskVersion = bitmask(zb0323)
}
case "msigthr":
- var zb0309 int
- zb0309, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0325 int
+ zb0325, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Threshold")
return
}
- if zb0309 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0309), uint64(maxEncodedTransactionGroups))
+ if zb0325 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0325), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedMsigs.Threshold, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedMsigs.Threshold)
@@ -15190,63 +16105,63 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "msigthrbm":
{
- var zb0310 []byte
- var zb0311 int
- zb0311, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0326 []byte
+ var zb0327 int
+ zb0327, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskThreshold")
return
}
- if zb0311 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0311), uint64(maxBitmaskSize))
+ if zb0327 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0327), uint64(maxBitmaskSize))
return
}
- zb0310, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskThreshold))
+ zb0326, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskThreshold))
if err != nil {
err = msgp.WrapError(err, "BitmaskThreshold")
return
}
- (*z).encodedMsigs.BitmaskThreshold = bitmask(zb0310)
+ (*z).encodedMsigs.BitmaskThreshold = bitmask(zb0326)
}
case "subsig":
- var zb0312 int
- var zb0313 bool
- zb0312, zb0313, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0328 int
+ var zb0329 bool
+ zb0328, zb0329, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Subsigs")
return
}
- if zb0312 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0312), uint64(maxEncodedTransactionGroups))
+ if zb0328 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0328), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Subsigs")
return
}
- if zb0313 {
+ if zb0329 {
(*z).encodedMsigs.Subsigs = nil
- } else if (*z).encodedMsigs.Subsigs != nil && cap((*z).encodedMsigs.Subsigs) >= zb0312 {
- (*z).encodedMsigs.Subsigs = ((*z).encodedMsigs.Subsigs)[:zb0312]
+ } else if (*z).encodedMsigs.Subsigs != nil && cap((*z).encodedMsigs.Subsigs) >= zb0328 {
+ (*z).encodedMsigs.Subsigs = ((*z).encodedMsigs.Subsigs)[:zb0328]
} else {
- (*z).encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0312)
+ (*z).encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0328)
}
for zb0001 := range (*z).encodedMsigs.Subsigs {
- var zb0314 int
- var zb0315 bool
- zb0314, zb0315, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0330 int
+ var zb0331 bool
+ zb0330, zb0331, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Subsigs", zb0001)
return
}
- if zb0314 > crypto.MaxMultisig {
- err = msgp.ErrOverflow(uint64(zb0314), uint64(crypto.MaxMultisig))
+ if zb0330 > crypto.MaxMultisig {
+ err = msgp.ErrOverflow(uint64(zb0330), uint64(crypto.MaxMultisig))
err = msgp.WrapError(err, "Subsigs", zb0001)
return
}
- if zb0315 {
+ if zb0331 {
(*z).encodedMsigs.Subsigs[zb0001] = nil
- } else if (*z).encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedMsigs.Subsigs[zb0001]) >= zb0314 {
- (*z).encodedMsigs.Subsigs[zb0001] = ((*z).encodedMsigs.Subsigs[zb0001])[:zb0314]
+ } else if (*z).encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedMsigs.Subsigs[zb0001]) >= zb0330 {
+ (*z).encodedMsigs.Subsigs[zb0001] = ((*z).encodedMsigs.Subsigs[zb0001])[:zb0330]
} else {
- (*z).encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0314)
+ (*z).encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0330)
}
for zb0002 := range (*z).encodedMsigs.Subsigs[zb0001] {
bts, err = (*z).encodedMsigs.Subsigs[zb0001][zb0002].UnmarshalMsg(bts)
@@ -15258,53 +16173,53 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "subsigsbm":
{
- var zb0316 []byte
- var zb0317 int
- zb0317, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0332 []byte
+ var zb0333 int
+ zb0333, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSubsigs")
return
}
- if zb0317 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0317), uint64(maxBitmaskSize))
+ if zb0333 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0333), uint64(maxBitmaskSize))
return
}
- zb0316, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskSubsigs))
+ zb0332, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedMsigs.BitmaskSubsigs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSubsigs")
return
}
- (*z).encodedMsigs.BitmaskSubsigs = bitmask(zb0316)
+ (*z).encodedMsigs.BitmaskSubsigs = bitmask(zb0332)
}
case "lsigl":
- var zb0318 int
- var zb0319 bool
- zb0318, zb0319, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0334 int
+ var zb0335 bool
+ zb0334, zb0335, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Logic")
return
}
- if zb0318 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0318), uint64(maxEncodedTransactionGroups))
+ if zb0334 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0334), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Logic")
return
}
- if zb0319 {
+ if zb0335 {
(*z).encodedLsigs.Logic = nil
- } else if (*z).encodedLsigs.Logic != nil && cap((*z).encodedLsigs.Logic) >= zb0318 {
- (*z).encodedLsigs.Logic = ((*z).encodedLsigs.Logic)[:zb0318]
+ } else if (*z).encodedLsigs.Logic != nil && cap((*z).encodedLsigs.Logic) >= zb0334 {
+ (*z).encodedLsigs.Logic = ((*z).encodedLsigs.Logic)[:zb0334]
} else {
- (*z).encodedLsigs.Logic = make([][]byte, zb0318)
+ (*z).encodedLsigs.Logic = make([][]byte, zb0334)
}
for zb0003 := range (*z).encodedLsigs.Logic {
- var zb0320 int
- zb0320, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0336 int
+ zb0336, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Logic", zb0003)
return
}
- if zb0320 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0320), uint64(config.MaxLogicSigMaxSize))
+ if zb0336 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0336), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedLsigs.Logic[zb0003], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedLsigs.Logic[zb0003])
@@ -15315,73 +16230,73 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lsiglbm":
{
- var zb0321 []byte
- var zb0322 int
- zb0322, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0337 []byte
+ var zb0338 int
+ zb0338, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLogic")
return
}
- if zb0322 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0322), uint64(maxBitmaskSize))
+ if zb0338 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0338), uint64(maxBitmaskSize))
return
}
- zb0321, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogic))
+ zb0337, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogic))
if err != nil {
err = msgp.WrapError(err, "BitmaskLogic")
return
}
- (*z).encodedLsigs.BitmaskLogic = bitmask(zb0321)
+ (*z).encodedLsigs.BitmaskLogic = bitmask(zb0337)
}
case "lsigarg":
- var zb0323 int
- var zb0324 bool
- zb0323, zb0324, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0339 int
+ var zb0340 bool
+ zb0339, zb0340, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs")
return
}
- if zb0323 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0323), uint64(maxEncodedTransactionGroups))
+ if zb0339 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0339), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LogicArgs")
return
}
- if zb0324 {
+ if zb0340 {
(*z).encodedLsigs.LogicArgs = nil
- } else if (*z).encodedLsigs.LogicArgs != nil && cap((*z).encodedLsigs.LogicArgs) >= zb0323 {
- (*z).encodedLsigs.LogicArgs = ((*z).encodedLsigs.LogicArgs)[:zb0323]
+ } else if (*z).encodedLsigs.LogicArgs != nil && cap((*z).encodedLsigs.LogicArgs) >= zb0339 {
+ (*z).encodedLsigs.LogicArgs = ((*z).encodedLsigs.LogicArgs)[:zb0339]
} else {
- (*z).encodedLsigs.LogicArgs = make([][][]byte, zb0323)
+ (*z).encodedLsigs.LogicArgs = make([][][]byte, zb0339)
}
for zb0004 := range (*z).encodedLsigs.LogicArgs {
- var zb0325 int
- var zb0326 bool
- zb0325, zb0326, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0341 int
+ var zb0342 bool
+ zb0341, zb0342, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs", zb0004)
return
}
- if zb0325 > transactions.EvalMaxArgs {
- err = msgp.ErrOverflow(uint64(zb0325), uint64(transactions.EvalMaxArgs))
+ if zb0341 > transactions.EvalMaxArgs {
+ err = msgp.ErrOverflow(uint64(zb0341), uint64(transactions.EvalMaxArgs))
err = msgp.WrapError(err, "LogicArgs", zb0004)
return
}
- if zb0326 {
+ if zb0342 {
(*z).encodedLsigs.LogicArgs[zb0004] = nil
- } else if (*z).encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedLsigs.LogicArgs[zb0004]) >= zb0325 {
- (*z).encodedLsigs.LogicArgs[zb0004] = ((*z).encodedLsigs.LogicArgs[zb0004])[:zb0325]
+ } else if (*z).encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedLsigs.LogicArgs[zb0004]) >= zb0341 {
+ (*z).encodedLsigs.LogicArgs[zb0004] = ((*z).encodedLsigs.LogicArgs[zb0004])[:zb0341]
} else {
- (*z).encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0325)
+ (*z).encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0341)
}
for zb0005 := range (*z).encodedLsigs.LogicArgs[zb0004] {
- var zb0327 int
- zb0327, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0343 int
+ zb0343, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs", zb0004, zb0005)
return
}
- if zb0327 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0327), uint64(config.MaxLogicSigMaxSize))
+ if zb0343 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0343), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedLsigs.LogicArgs[zb0004][zb0005], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedLsigs.LogicArgs[zb0004][zb0005])
@@ -15393,33 +16308,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lsigargbm":
{
- var zb0328 []byte
- var zb0329 int
- zb0329, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0344 []byte
+ var zb0345 int
+ zb0345, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLogicArgs")
return
}
- if zb0329 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0329), uint64(maxBitmaskSize))
+ if zb0345 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0345), uint64(maxBitmaskSize))
return
}
- zb0328, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogicArgs))
+ zb0344, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedLsigs.BitmaskLogicArgs))
if err != nil {
err = msgp.WrapError(err, "BitmaskLogicArgs")
return
}
- (*z).encodedLsigs.BitmaskLogicArgs = bitmask(zb0328)
+ (*z).encodedLsigs.BitmaskLogicArgs = bitmask(zb0344)
}
case "sgnr":
- var zb0330 int
- zb0330, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0346 int
+ zb0346, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AuthAddr")
return
}
- if zb0330 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0330), uint64(maxAddressBytes))
+ if zb0346 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0346), uint64(maxAddressBytes))
return
}
(*z).AuthAddr, bts, err = msgp.ReadBytesBytes(bts, (*z).AuthAddr)
@@ -15429,33 +16344,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sgnrbm":
{
- var zb0331 []byte
- var zb0332 int
- zb0332, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0347 []byte
+ var zb0348 int
+ zb0348, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAuthAddr")
return
}
- if zb0332 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0332), uint64(maxBitmaskSize))
+ if zb0348 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0348), uint64(maxBitmaskSize))
return
}
- zb0331, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskAuthAddr))
+ zb0347, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskAuthAddr))
if err != nil {
err = msgp.WrapError(err, "BitmaskAuthAddr")
return
}
- (*z).BitmaskAuthAddr = bitmask(zb0331)
+ (*z).BitmaskAuthAddr = bitmask(zb0347)
}
case "type":
- var zb0333 int
- zb0333, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0349 int
+ zb0349, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "TxType")
return
}
- if zb0333 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0333), uint64(maxEncodedTransactionGroups))
+ if zb0349 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0349), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedTxns.TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.TxType)
@@ -15465,23 +16380,23 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "typebm":
{
- var zb0334 []byte
- var zb0335 int
- zb0335, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0350 []byte
+ var zb0351 int
+ zb0351, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- if zb0335 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0335), uint64(maxBitmaskSize))
+ if zb0351 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0351), uint64(maxBitmaskSize))
return
}
- zb0334, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.BitmaskTxType))
+ zb0350, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- (*z).encodedTxns.BitmaskTxType = bitmask(zb0334)
+ (*z).encodedTxns.BitmaskTxType = bitmask(zb0350)
}
case "typeo":
(*z).encodedTxns.TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
@@ -15490,14 +16405,14 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "snd":
- var zb0336 int
- zb0336, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0352 int
+ zb0352, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Sender")
return
}
- if zb0336 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0336), uint64(maxAddressBytes))
+ if zb0352 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0352), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Sender)
@@ -15507,43 +16422,43 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sndbm":
{
- var zb0337 []byte
- var zb0338 int
- zb0338, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0353 []byte
+ var zb0354 int
+ zb0354, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- if zb0338 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0338), uint64(maxBitmaskSize))
+ if zb0354 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0354), uint64(maxBitmaskSize))
return
}
- zb0337, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskSender))
+ zb0353, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0337)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0353)
}
case "fee":
- var zb0339 int
- var zb0340 bool
- zb0339, zb0340, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0355 int
+ var zb0356 bool
+ zb0355, zb0356, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Fee")
return
}
- if zb0339 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0339), uint64(maxEncodedTransactionGroups))
+ if zb0355 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0355), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Fee")
return
}
- if zb0340 {
+ if zb0356 {
(*z).encodedTxns.encodedTxnHeaders.Fee = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedTxns.encodedTxnHeaders.Fee) >= zb0339 {
- (*z).encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedTxns.encodedTxnHeaders.Fee)[:zb0339]
+ } else if (*z).encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedTxns.encodedTxnHeaders.Fee) >= zb0355 {
+ (*z).encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedTxns.encodedTxnHeaders.Fee)[:zb0355]
} else {
- (*z).encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0339)
+ (*z).encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0355)
}
for zb0006 := range (*z).encodedTxns.encodedTxnHeaders.Fee {
bts, err = (*z).encodedTxns.encodedTxnHeaders.Fee[zb0006].UnmarshalMsg(bts)
@@ -15554,43 +16469,43 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "feebm":
{
- var zb0341 []byte
- var zb0342 int
- zb0342, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0357 []byte
+ var zb0358 int
+ zb0358, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- if zb0342 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0342), uint64(maxBitmaskSize))
+ if zb0358 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0358), uint64(maxBitmaskSize))
return
}
- zb0341, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFee))
+ zb0357, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0341)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0357)
}
case "fv":
- var zb0343 int
- var zb0344 bool
- zb0343, zb0344, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0359 int
+ var zb0360 bool
+ zb0359, zb0360, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0343 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0343), uint64(maxEncodedTransactionGroups))
+ if zb0359 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0359), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0344 {
+ if zb0360 {
(*z).encodedTxns.encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.FirstValid) >= zb0343 {
- (*z).encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedTxns.encodedTxnHeaders.FirstValid)[:zb0343]
+ } else if (*z).encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.FirstValid) >= zb0359 {
+ (*z).encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedTxns.encodedTxnHeaders.FirstValid)[:zb0359]
} else {
- (*z).encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0343)
+ (*z).encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0359)
}
for zb0007 := range (*z).encodedTxns.encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedTxns.encodedTxnHeaders.FirstValid[zb0007].UnmarshalMsg(bts)
@@ -15601,43 +16516,43 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fvbm":
{
- var zb0345 []byte
- var zb0346 int
- zb0346, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0361 []byte
+ var zb0362 int
+ zb0362, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- if zb0346 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0346), uint64(maxBitmaskSize))
+ if zb0362 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0362), uint64(maxBitmaskSize))
return
}
- zb0345, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
+ zb0361, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0345)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0361)
}
case "lv":
- var zb0347 int
- var zb0348 bool
- zb0347, zb0348, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0363 int
+ var zb0364 bool
+ zb0363, zb0364, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0347 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0347), uint64(maxEncodedTransactionGroups))
+ if zb0363 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0363), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0348 {
+ if zb0364 {
(*z).encodedTxns.encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.LastValid) >= zb0347 {
- (*z).encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedTxns.encodedTxnHeaders.LastValid)[:zb0347]
+ } else if (*z).encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxns.encodedTxnHeaders.LastValid) >= zb0363 {
+ (*z).encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedTxns.encodedTxnHeaders.LastValid)[:zb0363]
} else {
- (*z).encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0347)
+ (*z).encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0363)
}
for zb0008 := range (*z).encodedTxns.encodedTxnHeaders.LastValid {
bts, err = (*z).encodedTxns.encodedTxnHeaders.LastValid[zb0008].UnmarshalMsg(bts)
@@ -15648,53 +16563,53 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lvbm":
{
- var zb0349 []byte
- var zb0350 int
- zb0350, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0365 []byte
+ var zb0366 int
+ zb0366, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- if zb0350 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0350), uint64(maxBitmaskSize))
+ if zb0366 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0366), uint64(maxBitmaskSize))
return
}
- zb0349, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid))
+ zb0365, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0349)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0365)
}
case "note":
- var zb0351 int
- var zb0352 bool
- zb0351, zb0352, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0367 int
+ var zb0368 bool
+ zb0367, zb0368, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Note")
return
}
- if zb0351 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0351), uint64(maxEncodedTransactionGroups))
+ if zb0367 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0367), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Note")
return
}
- if zb0352 {
+ if zb0368 {
(*z).encodedTxns.encodedTxnHeaders.Note = nil
- } else if (*z).encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedTxns.encodedTxnHeaders.Note) >= zb0351 {
- (*z).encodedTxns.encodedTxnHeaders.Note = ((*z).encodedTxns.encodedTxnHeaders.Note)[:zb0351]
+ } else if (*z).encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedTxns.encodedTxnHeaders.Note) >= zb0367 {
+ (*z).encodedTxns.encodedTxnHeaders.Note = ((*z).encodedTxns.encodedTxnHeaders.Note)[:zb0367]
} else {
- (*z).encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0351)
+ (*z).encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0367)
}
for zb0009 := range (*z).encodedTxns.encodedTxnHeaders.Note {
- var zb0353 int
- zb0353, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0369 int
+ zb0369, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Note", zb0009)
return
}
- if zb0353 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0353), uint64(config.MaxTxnNoteBytes))
+ if zb0369 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0369), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Note[zb0009], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Note[zb0009])
@@ -15705,73 +16620,73 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "notebm":
{
- var zb0354 []byte
- var zb0355 int
- zb0355, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0370 []byte
+ var zb0371 int
+ zb0371, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- if zb0355 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0355), uint64(maxBitmaskSize))
+ if zb0371 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0371), uint64(maxBitmaskSize))
return
}
- zb0354, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskNote))
+ zb0370, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0354)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0370)
}
case "genbm":
{
- var zb0356 []byte
- var zb0357 int
- zb0357, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0372 []byte
+ var zb0373 int
+ zb0373, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- if zb0357 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0357), uint64(maxBitmaskSize))
+ if zb0373 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0373), uint64(maxBitmaskSize))
return
}
- zb0356, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
+ zb0372, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0356)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0372)
}
case "grpbm":
{
- var zb0358 []byte
- var zb0359 int
- zb0359, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0374 []byte
+ var zb0375 int
+ zb0375, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- if zb0359 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0359), uint64(maxBitmaskSize))
+ if zb0375 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0375), uint64(maxBitmaskSize))
return
}
- zb0358, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup))
+ zb0374, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0358)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0374)
}
case "lx":
- var zb0360 int
- zb0360, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0376 int
+ zb0376, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Lease")
return
}
- if zb0360 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0360), uint64(maxAddressBytes))
+ if zb0376 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0376), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.Lease)
@@ -15781,33 +16696,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lxbm":
{
- var zb0361 []byte
- var zb0362 int
- zb0362, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0377 []byte
+ var zb0378 int
+ zb0378, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- if zb0362 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0362), uint64(maxBitmaskSize))
+ if zb0378 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0378), uint64(maxBitmaskSize))
return
}
- zb0361, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLease))
+ zb0377, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0361)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0377)
}
case "rekey":
- var zb0363 int
- zb0363, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0379 int
+ zb0379, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "RekeyTo")
return
}
- if zb0363 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0363), uint64(maxAddressBytes))
+ if zb0379 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0379), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedTxnHeaders.RekeyTo)
@@ -15817,33 +16732,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rekeybm":
{
- var zb0364 []byte
- var zb0365 int
- zb0365, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0380 []byte
+ var zb0381 int
+ zb0381, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- if zb0365 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0365), uint64(maxBitmaskSize))
+ if zb0381 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0381), uint64(maxBitmaskSize))
return
}
- zb0364, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
+ zb0380, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- (*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0364)
+ (*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0380)
}
case "votekey":
- var zb0366 int
- zb0366, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0382 int
+ zb0382, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "VotePK")
return
}
- if zb0366 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0366), uint64(maxAddressBytes))
+ if zb0382 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0382), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.VotePK)
@@ -15852,14 +16767,14 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "selkey":
- var zb0367 int
- zb0367, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0383 int
+ zb0383, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "SelectionPK")
return
}
- if zb0367 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0367), uint64(maxAddressBytes))
+ if zb0383 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0383), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.SelectionPK)
@@ -15868,24 +16783,24 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "votefst":
- var zb0368 int
- var zb0369 bool
- zb0368, zb0369, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0384 int
+ var zb0385 bool
+ zb0384, zb0385, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0368 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0368), uint64(maxEncodedTransactionGroups))
+ if zb0384 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0384), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0369 {
+ if zb0385 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0368 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0368]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0384 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0384]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0368)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0384)
}
for zb0010 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].UnmarshalMsg(bts)
@@ -15896,43 +16811,43 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votefstbm":
{
- var zb0370 []byte
- var zb0371 int
- zb0371, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0386 []byte
+ var zb0387 int
+ zb0387, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- if zb0371 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0371), uint64(maxBitmaskSize))
+ if zb0387 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0387), uint64(maxBitmaskSize))
return
}
- zb0370, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0386, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0370)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0386)
}
case "votelst":
- var zb0372 int
- var zb0373 bool
- zb0372, zb0373, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0388 int
+ var zb0389 bool
+ zb0388, zb0389, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0372 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0372), uint64(maxEncodedTransactionGroups))
+ if zb0388 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0388), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0373 {
+ if zb0389 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0372 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0372]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0388 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0388]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0372)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0388)
}
for zb0011 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].UnmarshalMsg(bts)
@@ -15943,43 +16858,43 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votelstbm":
{
- var zb0374 []byte
- var zb0375 int
- zb0375, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0390 []byte
+ var zb0391 int
+ zb0391, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- if zb0375 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0375), uint64(maxBitmaskSize))
+ if zb0391 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0391), uint64(maxBitmaskSize))
return
}
- zb0374, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0390, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0374)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0390)
}
case "votekd":
- var zb0376 int
- var zb0377 bool
- zb0376, zb0377, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0392 int
+ var zb0393 bool
+ zb0392, zb0393, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0376 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0376), uint64(maxEncodedTransactionGroups))
+ if zb0392 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0392), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0377 {
+ if zb0393 {
(*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0376 {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0376]
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0392 {
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0392]
} else {
- (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0376)
+ (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0392)
}
for zb0012 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012], bts, err = msgp.ReadUint64Bytes(bts)
@@ -15990,53 +16905,96 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votekbm":
{
- var zb0378 []byte
- var zb0379 int
- zb0379, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0394 []byte
+ var zb0395 int
+ zb0395, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- if zb0379 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0379), uint64(maxBitmaskSize))
+ if zb0395 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0395), uint64(maxBitmaskSize))
return
}
- zb0378, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
+ zb0394, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0378)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0394)
}
case "nonpartbm":
{
- var zb0380 []byte
- var zb0381 int
- zb0381, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0396 []byte
+ var zb0397 int
+ zb0397, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- if zb0381 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0381), uint64(maxBitmaskSize))
+ if zb0397 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0397), uint64(maxBitmaskSize))
return
}
- zb0380, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0396, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- (*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0380)
+ (*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0396)
+ }
+ case "vldrt":
+ var zb0398 int
+ var zb0399 bool
+ zb0398, zb0399, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0398 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0398), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0399 {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot) >= zb0398 {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = ((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot)[:zb0398]
+ } else {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0398)
+ }
+ for zb0013 := range (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot", zb0013)
+ return
+ }
+ }
+ case "comt":
+ var zb0400 int
+ zb0400, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
+ }
+ if zb0400 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0400), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
}
case "rcv":
- var zb0382 int
- zb0382, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0401 int
+ zb0401, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Receiver")
return
}
- if zb0382 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0382), uint64(maxAddressBytes))
+ if zb0401 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0401), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedPaymentTxnFields.Receiver)
@@ -16046,80 +17004,80 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rcvbm":
{
- var zb0383 []byte
- var zb0384 int
- zb0384, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0402 []byte
+ var zb0403 int
+ zb0403, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- if zb0384 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0384), uint64(maxBitmaskSize))
+ if zb0403 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0403), uint64(maxBitmaskSize))
return
}
- zb0383, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
+ zb0402, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0383)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0402)
}
case "amt":
- var zb0385 int
- var zb0386 bool
- zb0385, zb0386, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0404 int
+ var zb0405 bool
+ zb0404, zb0405, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Amount")
return
}
- if zb0385 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0385), uint64(maxEncodedTransactionGroups))
+ if zb0404 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0404), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Amount")
return
}
- if zb0386 {
+ if zb0405 {
(*z).encodedTxns.encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedTxns.encodedPaymentTxnFields.Amount) >= zb0385 {
- (*z).encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedTxns.encodedPaymentTxnFields.Amount)[:zb0385]
+ } else if (*z).encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedTxns.encodedPaymentTxnFields.Amount) >= zb0404 {
+ (*z).encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedTxns.encodedPaymentTxnFields.Amount)[:zb0404]
} else {
- (*z).encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0385)
+ (*z).encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0404)
}
- for zb0013 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0013].UnmarshalMsg(bts)
+ for zb0014 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0014].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Amount", zb0013)
+ err = msgp.WrapError(err, "Amount", zb0014)
return
}
}
case "amtbm":
{
- var zb0387 []byte
- var zb0388 int
- zb0388, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0406 []byte
+ var zb0407 int
+ zb0407, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- if zb0388 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0388), uint64(maxBitmaskSize))
+ if zb0407 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0407), uint64(maxBitmaskSize))
return
}
- zb0387, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
+ zb0406, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0387)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0406)
}
case "close":
- var zb0389 int
- zb0389, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0408 int
+ zb0408, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "CloseRemainderTo")
return
}
- if zb0389 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0389), uint64(maxAddressBytes))
+ if zb0408 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0408), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
@@ -16129,335 +17087,335 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "closebm":
{
- var zb0390 []byte
- var zb0391 int
- zb0391, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0409 []byte
+ var zb0410 int
+ zb0410, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- if zb0391 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0391), uint64(maxBitmaskSize))
+ if zb0410 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0410), uint64(maxBitmaskSize))
return
}
- zb0390, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0409, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- (*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0390)
+ (*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0409)
}
case "caid":
- var zb0392 int
- var zb0393 bool
- zb0392, zb0393, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0411 int
+ var zb0412 bool
+ zb0411, zb0412, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0392 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0392), uint64(maxEncodedTransactionGroups))
+ if zb0411 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0411), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0393 {
+ if zb0412 {
(*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0392 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0392]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0411 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0411]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0392)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0411)
}
- for zb0014 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].UnmarshalMsg(bts)
+ for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ConfigAsset", zb0014)
+ err = msgp.WrapError(err, "ConfigAsset", zb0015)
return
}
}
case "caidbm":
{
- var zb0394 []byte
- var zb0395 int
- zb0395, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0413 []byte
+ var zb0414 int
+ zb0414, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- if zb0395 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0395), uint64(maxBitmaskSize))
+ if zb0414 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0414), uint64(maxBitmaskSize))
return
}
- zb0394, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0413, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0394)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0413)
}
case "t":
- var zb0396 int
- var zb0397 bool
- zb0396, zb0397, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0415 int
+ var zb0416 bool
+ zb0415, zb0416, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Total")
return
}
- if zb0396 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0396), uint64(maxEncodedTransactionGroups))
+ if zb0415 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0415), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Total")
return
}
- if zb0397 {
+ if zb0416 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0396 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0396]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0415 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0415]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0396)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0415)
}
- for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Total", zb0015)
+ err = msgp.WrapError(err, "Total", zb0016)
return
}
}
case "tbm":
{
- var zb0398 []byte
- var zb0399 int
- zb0399, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0417 []byte
+ var zb0418 int
+ zb0418, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- if zb0399 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0399), uint64(maxBitmaskSize))
+ if zb0418 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0418), uint64(maxBitmaskSize))
return
}
- zb0398, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0417, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0398)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0417)
}
case "dc":
- var zb0400 int
- var zb0401 bool
- zb0400, zb0401, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0419 int
+ var zb0420 bool
+ zb0419, zb0420, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0400 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0400), uint64(maxEncodedTransactionGroups))
+ if zb0419 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0419), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0401 {
+ if zb0420 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0400 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0400]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0419 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0419]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0400)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0419)
}
- for zb0016 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Decimals", zb0016)
+ err = msgp.WrapError(err, "Decimals", zb0017)
return
}
}
case "dcbm":
{
- var zb0402 []byte
- var zb0403 int
- zb0403, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0421 []byte
+ var zb0422 int
+ zb0422, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- if zb0403 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0403), uint64(maxBitmaskSize))
+ if zb0422 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0422), uint64(maxBitmaskSize))
return
}
- zb0402, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0421, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0402)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0421)
}
case "dfbm":
{
- var zb0404 []byte
- var zb0405 int
- zb0405, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0423 []byte
+ var zb0424 int
+ zb0424, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- if zb0405 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0405), uint64(maxBitmaskSize))
+ if zb0424 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0424), uint64(maxBitmaskSize))
return
}
- zb0404, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0423, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0404)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0423)
}
case "un":
- var zb0406 int
- var zb0407 bool
- zb0406, zb0407, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0425 int
+ var zb0426 bool
+ zb0425, zb0426, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0406 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0406), uint64(maxEncodedTransactionGroups))
+ if zb0425 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0425), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0407 {
+ if zb0426 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0406 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0406]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0425 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0425]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0406)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0425)
}
- for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017], bts, err = msgp.ReadStringBytes(bts)
+ for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "UnitName", zb0017)
+ err = msgp.WrapError(err, "UnitName", zb0018)
return
}
}
case "unbm":
{
- var zb0408 []byte
- var zb0409 int
- zb0409, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0427 []byte
+ var zb0428 int
+ zb0428, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- if zb0409 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0409), uint64(maxBitmaskSize))
+ if zb0428 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0428), uint64(maxBitmaskSize))
return
}
- zb0408, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0427, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0408)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0427)
}
case "an":
- var zb0410 int
- var zb0411 bool
- zb0410, zb0411, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0429 int
+ var zb0430 bool
+ zb0429, zb0430, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0410 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0410), uint64(maxEncodedTransactionGroups))
+ if zb0429 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0429), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0411 {
+ if zb0430 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0410 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0410]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0429 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0429]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0410)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0429)
}
- for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018], bts, err = msgp.ReadStringBytes(bts)
+ for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetName", zb0018)
+ err = msgp.WrapError(err, "AssetName", zb0019)
return
}
}
case "anbm":
{
- var zb0412 []byte
- var zb0413 int
- zb0413, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0431 []byte
+ var zb0432 int
+ zb0432, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- if zb0413 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0413), uint64(maxBitmaskSize))
+ if zb0432 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0432), uint64(maxBitmaskSize))
return
}
- zb0412, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0431, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0412)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0431)
}
case "au":
- var zb0414 int
- var zb0415 bool
- zb0414, zb0415, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0433 int
+ var zb0434 bool
+ zb0433, zb0434, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "URL")
return
}
- if zb0414 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0414), uint64(maxEncodedTransactionGroups))
+ if zb0433 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0433), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "URL")
return
}
- if zb0415 {
+ if zb0434 {
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0414 {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0414]
+ } else if (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0433 {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0433]
} else {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0414)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0433)
}
- for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019], bts, err = msgp.ReadStringBytes(bts)
+ for zb0020 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "URL", zb0019)
+ err = msgp.WrapError(err, "URL", zb0020)
return
}
}
case "aubm":
{
- var zb0416 []byte
- var zb0417 int
- zb0417, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0435 []byte
+ var zb0436 int
+ zb0436, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- if zb0417 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0417), uint64(maxBitmaskSize))
+ if zb0436 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0436), uint64(maxBitmaskSize))
return
}
- zb0416, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0435, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0416)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0435)
}
case "am":
- var zb0418 int
- zb0418, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0437 int
+ zb0437, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "MetadataHash")
return
}
- if zb0418 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0418), uint64(maxAddressBytes))
+ if zb0437 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0437), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -16467,33 +17425,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "ambm":
{
- var zb0419 []byte
- var zb0420 int
- zb0420, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0438 []byte
+ var zb0439 int
+ zb0439, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- if zb0420 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0420), uint64(maxBitmaskSize))
+ if zb0439 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0439), uint64(maxBitmaskSize))
return
}
- zb0419, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0438, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0419)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0438)
}
case "m":
- var zb0421 int
- zb0421, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0440 int
+ zb0440, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Manager")
return
}
- if zb0421 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0421), uint64(maxAddressBytes))
+ if zb0440 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0440), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -16503,33 +17461,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "mbm":
{
- var zb0422 []byte
- var zb0423 int
- zb0423, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0441 []byte
+ var zb0442 int
+ zb0442, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- if zb0423 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0423), uint64(maxBitmaskSize))
+ if zb0442 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0442), uint64(maxBitmaskSize))
return
}
- zb0422, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0441, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0422)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0441)
}
case "r":
- var zb0424 int
- zb0424, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0443 int
+ zb0443, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Reserve")
return
}
- if zb0424 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0424), uint64(maxAddressBytes))
+ if zb0443 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0443), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -16539,33 +17497,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rbm":
{
- var zb0425 []byte
- var zb0426 int
- zb0426, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0444 []byte
+ var zb0445 int
+ zb0445, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- if zb0426 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0426), uint64(maxBitmaskSize))
+ if zb0445 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0445), uint64(maxBitmaskSize))
return
}
- zb0425, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0444, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0425)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0444)
}
case "f":
- var zb0427 int
- zb0427, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0446 int
+ zb0446, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Freeze")
return
}
- if zb0427 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0427), uint64(maxAddressBytes))
+ if zb0446 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0446), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -16575,33 +17533,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fbm":
{
- var zb0428 []byte
- var zb0429 int
- zb0429, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0447 []byte
+ var zb0448 int
+ zb0448, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- if zb0429 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0429), uint64(maxBitmaskSize))
+ if zb0448 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0448), uint64(maxBitmaskSize))
return
}
- zb0428, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0447, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0428)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0447)
}
case "c":
- var zb0430 int
- zb0430, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0449 int
+ zb0449, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Clawback")
return
}
- if zb0430 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0430), uint64(maxAddressBytes))
+ if zb0449 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0449), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -16611,127 +17569,127 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "cbm":
{
- var zb0431 []byte
- var zb0432 int
- zb0432, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0450 []byte
+ var zb0451 int
+ zb0451, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- if zb0432 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0432), uint64(maxBitmaskSize))
+ if zb0451 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0451), uint64(maxBitmaskSize))
return
}
- zb0431, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0450, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0431)
+ (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0450)
}
case "xaid":
- var zb0433 int
- var zb0434 bool
- zb0433, zb0434, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0452 int
+ var zb0453 bool
+ zb0452, zb0453, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0433 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0433), uint64(maxEncodedTransactionGroups))
+ if zb0452 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0452), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0434 {
+ if zb0453 {
(*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0433 {
- (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0433]
+ } else if (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0452 {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0452]
} else {
- (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0433)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0452)
}
- for zb0020 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].UnmarshalMsg(bts)
+ for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "XferAsset", zb0020)
+ err = msgp.WrapError(err, "XferAsset", zb0021)
return
}
}
case "xaidbm":
{
- var zb0435 []byte
- var zb0436 int
- zb0436, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0454 []byte
+ var zb0455 int
+ zb0455, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- if zb0436 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0436), uint64(maxBitmaskSize))
+ if zb0455 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0455), uint64(maxBitmaskSize))
return
}
- zb0435, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0454, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0435)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0454)
}
case "aamt":
- var zb0437 int
- var zb0438 bool
- zb0437, zb0438, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0456 int
+ var zb0457 bool
+ zb0456, zb0457, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0437 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0437), uint64(maxEncodedTransactionGroups))
+ if zb0456 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0456), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0438 {
+ if zb0457 {
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0437 {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0437]
+ } else if (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0456 {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0456]
} else {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0437)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0456)
}
- for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0022 := range (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetAmount", zb0021)
+ err = msgp.WrapError(err, "AssetAmount", zb0022)
return
}
}
case "aamtbm":
{
- var zb0439 []byte
- var zb0440 int
- zb0440, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0458 []byte
+ var zb0459 int
+ zb0459, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- if zb0440 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0440), uint64(maxBitmaskSize))
+ if zb0459 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0459), uint64(maxBitmaskSize))
return
}
- zb0439, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0458, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0439)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0458)
}
case "asnd":
- var zb0441 int
- zb0441, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0460 int
+ zb0460, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetSender")
return
}
- if zb0441 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0441), uint64(maxAddressBytes))
+ if zb0460 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0460), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender)
@@ -16741,33 +17699,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "asndbm":
{
- var zb0442 []byte
- var zb0443 int
- zb0443, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0461 []byte
+ var zb0462 int
+ zb0462, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- if zb0443 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0443), uint64(maxBitmaskSize))
+ if zb0462 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0462), uint64(maxBitmaskSize))
return
}
- zb0442, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0461, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0442)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0461)
}
case "arcv":
- var zb0444 int
- zb0444, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0463 int
+ zb0463, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetReceiver")
return
}
- if zb0444 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0444), uint64(maxAddressBytes))
+ if zb0463 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0463), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
@@ -16777,33 +17735,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "arcvbm":
{
- var zb0445 []byte
- var zb0446 int
- zb0446, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0464 []byte
+ var zb0465 int
+ zb0465, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- if zb0446 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0446), uint64(maxBitmaskSize))
+ if zb0465 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0465), uint64(maxBitmaskSize))
return
}
- zb0445, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0464, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0445)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0464)
}
case "aclose":
- var zb0447 int
- zb0447, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0466 int
+ zb0466, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetCloseTo")
return
}
- if zb0447 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0447), uint64(maxAddressBytes))
+ if zb0466 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0466), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
@@ -16813,33 +17771,33 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "aclosebm":
{
- var zb0448 []byte
- var zb0449 int
- zb0449, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0467 []byte
+ var zb0468 int
+ zb0468, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- if zb0449 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0449), uint64(maxBitmaskSize))
+ if zb0468 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0468), uint64(maxBitmaskSize))
return
}
- zb0448, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0467, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0448)
+ (*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0467)
}
case "fadd":
- var zb0450 int
- zb0450, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0469 int
+ zb0469, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAccount")
return
}
- if zb0450 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0450), uint64(maxAddressBytes))
+ if zb0469 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0469), uint64(maxAddressBytes))
return
}
(*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
@@ -16849,147 +17807,147 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "faddbm":
{
- var zb0451 []byte
- var zb0452 int
- zb0452, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0470 []byte
+ var zb0471 int
+ zb0471, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- if zb0452 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0452), uint64(maxBitmaskSize))
+ if zb0471 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0471), uint64(maxBitmaskSize))
return
}
- zb0451, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0470, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0451)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0470)
}
case "faid":
- var zb0453 int
- var zb0454 bool
- zb0453, zb0454, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0472 int
+ var zb0473 bool
+ zb0472, zb0473, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0453 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0453), uint64(maxEncodedTransactionGroups))
+ if zb0472 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0472), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0454 {
+ if zb0473 {
(*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0453 {
- (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0453]
+ } else if (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0472 {
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0472]
} else {
- (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0453)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0472)
}
- for zb0022 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "FreezeAsset", zb0022)
+ err = msgp.WrapError(err, "FreezeAsset", zb0023)
return
}
}
case "faidbm":
{
- var zb0455 []byte
- var zb0456 int
- zb0456, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0474 []byte
+ var zb0475 int
+ zb0475, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- if zb0456 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0456), uint64(maxBitmaskSize))
+ if zb0475 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0475), uint64(maxBitmaskSize))
return
}
- zb0455, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0474, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0455)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0474)
}
case "afrzbm":
{
- var zb0457 []byte
- var zb0458 int
- zb0458, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0476 []byte
+ var zb0477 int
+ zb0477, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- if zb0458 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0458), uint64(maxBitmaskSize))
+ if zb0477 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0477), uint64(maxBitmaskSize))
return
}
- zb0457, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0476, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0457)
+ (*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0476)
}
case "apid":
- var zb0459 int
- var zb0460 bool
- zb0459, zb0460, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0478 int
+ var zb0479 bool
+ zb0478, zb0479, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0459 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0459), uint64(maxEncodedTransactionGroups))
+ if zb0478 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0478), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0460 {
+ if zb0479 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0459 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0459]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0478 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0478]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0459)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0478)
}
- for zb0023 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].UnmarshalMsg(bts)
+ for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationID", zb0023)
+ err = msgp.WrapError(err, "ApplicationID", zb0024)
return
}
}
case "apidbm":
{
- var zb0461 []byte
- var zb0462 int
- zb0462, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0480 []byte
+ var zb0481 int
+ zb0481, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- if zb0462 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0462), uint64(maxBitmaskSize))
+ if zb0481 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0481), uint64(maxBitmaskSize))
return
}
- zb0461, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0480, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0461)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0480)
}
case "apan":
- var zb0463 int
- zb0463, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0482 int
+ zb0482, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "OnCompletion")
return
}
- if zb0463 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0463), uint64(maxEncodedTransactionGroups))
+ if zb0482 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0482), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
@@ -16999,1040 +17957,1145 @@ func (z *encodedSignedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "apanbm":
{
- var zb0464 []byte
- var zb0465 int
- zb0465, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0483 []byte
+ var zb0484 int
+ zb0484, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- if zb0465 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0465), uint64(maxBitmaskSize))
+ if zb0484 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0484), uint64(maxBitmaskSize))
return
}
- zb0464, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0483, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0464)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0483)
}
case "apaa":
- var zb0466 int
- var zb0467 bool
- zb0466, zb0467, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0485 int
+ var zb0486 bool
+ zb0485, zb0486, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0466 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0466), uint64(maxEncodedTransactionGroups))
+ if zb0485 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0485), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0467 {
+ if zb0486 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0466 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0466]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0485 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0485]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0466)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0485)
}
- for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0468 int
- var zb0469 bool
- zb0468, zb0469, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0487 int
+ var zb0488 bool
+ zb0487, zb0488, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0024)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025)
return
}
- if zb0468 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0468), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "ApplicationArgs", zb0024)
+ if zb0487 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0487), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025)
return
}
- if zb0469 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024]) >= zb0468 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])[:zb0468]
+ if zb0488 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025]) >= zb0487 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])[:zb0487]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = make(applicationArgs, zb0468)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = make(applicationArgs, zb0487)
}
- for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0024, zb0025)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025, zb0026)
return
}
}
}
case "apaabm":
{
- var zb0470 []byte
- var zb0471 int
- zb0471, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0489 []byte
+ var zb0490 int
+ zb0490, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- if zb0471 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0471), uint64(maxBitmaskSize))
+ if zb0490 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0490), uint64(maxBitmaskSize))
return
}
- zb0470, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0489, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0470)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0489)
}
case "apat":
- var zb0472 int
- var zb0473 bool
- zb0472, zb0473, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0491 int
+ var zb0492 bool
+ zb0491, zb0492, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0472 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0472), uint64(maxEncodedTransactionGroups))
+ if zb0491 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0491), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0473 {
+ if zb0492 {
(*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0472 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0472]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0491 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0491]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0472)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0491)
}
- for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
- var zb0474 int
- var zb0475 bool
- zb0474, zb0475, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ var zb0493 int
+ var zb0494 bool
+ zb0493, zb0494, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0026)
+ err = msgp.WrapError(err, "Accounts", zb0027)
return
}
- if zb0474 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0474), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "Accounts", zb0026)
+ if zb0493 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0493), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "Accounts", zb0027)
return
}
- if zb0475 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026]) >= zb0474 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])[:zb0474]
+ if zb0494 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027]) >= zb0493 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = ((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])[:zb0493]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = make(addresses, zb0474)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = make(addresses, zb0493)
}
- for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].UnmarshalMsg(bts)
+ for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0026, zb0027)
+ err = msgp.WrapError(err, "Accounts", zb0027, zb0028)
return
}
}
}
case "apatbm":
{
- var zb0476 []byte
- var zb0477 int
- zb0477, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0495 []byte
+ var zb0496 int
+ zb0496, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- if zb0477 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0477), uint64(maxBitmaskSize))
+ if zb0496 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0496), uint64(maxBitmaskSize))
return
}
- zb0476, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0495, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0476)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0495)
}
case "apfa":
- var zb0478 int
- var zb0479 bool
- zb0478, zb0479, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0497 int
+ var zb0498 bool
+ zb0497, zb0498, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0478 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0478), uint64(maxEncodedTransactionGroups))
+ if zb0497 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0497), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0479 {
+ if zb0498 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0478 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0478]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0497 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0497]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0478)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0497)
}
- for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- var zb0480 int
- var zb0481 bool
- zb0480, zb0481, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ var zb0499 int
+ var zb0500 bool
+ zb0499, zb0500, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0028)
+ err = msgp.WrapError(err, "ForeignApps", zb0029)
return
}
- if zb0480 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0480), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "ForeignApps", zb0028)
+ if zb0499 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0499), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "ForeignApps", zb0029)
return
}
- if zb0481 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028]) >= zb0480 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])[:zb0480]
+ if zb0500 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029]) >= zb0499 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])[:zb0499]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = make(appIndices, zb0480)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = make(appIndices, zb0499)
}
- for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].UnmarshalMsg(bts)
+ for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0028, zb0029)
+ err = msgp.WrapError(err, "ForeignApps", zb0029, zb0030)
return
}
}
}
case "apfabm":
{
- var zb0482 []byte
- var zb0483 int
- zb0483, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0501 []byte
+ var zb0502 int
+ zb0502, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- if zb0483 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0483), uint64(maxBitmaskSize))
+ if zb0502 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0502), uint64(maxBitmaskSize))
return
}
- zb0482, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0501, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0482)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0501)
}
case "apas":
- var zb0484 int
- var zb0485 bool
- zb0484, zb0485, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0503 int
+ var zb0504 bool
+ zb0503, zb0504, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0484 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0484), uint64(maxEncodedTransactionGroups))
+ if zb0503 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0503), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0485 {
+ if zb0504 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0484 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0484]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0503 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0503]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0484)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0503)
}
- for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- var zb0486 int
- var zb0487 bool
- zb0486, zb0487, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0505 int
+ var zb0506 bool
+ zb0505, zb0506, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0030)
+ err = msgp.WrapError(err, "ForeignAssets", zb0031)
return
}
- if zb0486 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0486), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "ForeignAssets", zb0030)
+ if zb0505 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0505), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "ForeignAssets", zb0031)
return
}
- if zb0487 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030]) >= zb0486 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])[:zb0486]
+ if zb0506 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = nil
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031]) >= zb0505 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = ((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])[:zb0505]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = make(assetIndices, zb0486)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = make(assetIndices, zb0505)
}
- for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].UnmarshalMsg(bts)
+ for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ bts, err = (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0030, zb0031)
+ err = msgp.WrapError(err, "ForeignAssets", zb0031, zb0032)
return
}
}
}
case "apasbm":
{
- var zb0488 []byte
- var zb0489 int
- zb0489, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0507 []byte
+ var zb0508 int
+ zb0508, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- if zb0489 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0489), uint64(maxBitmaskSize))
+ if zb0508 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0508), uint64(maxBitmaskSize))
return
}
- zb0488, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0507, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0488)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0507)
}
case "lnui":
- var zb0490 int
- var zb0491 bool
- zb0490, zb0491, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0509 int
+ var zb0510 bool
+ zb0509, zb0510, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0490 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0490), uint64(maxEncodedTransactionGroups))
+ if zb0509 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0509), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0491 {
+ if zb0510 {
(*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0490 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0490]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0509 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0509]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0490)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0509)
}
- for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumUint", zb0032)
+ err = msgp.WrapError(err, "LocalNumUint", zb0033)
return
}
}
case "lnuibm":
{
- var zb0492 []byte
- var zb0493 int
- zb0493, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0511 []byte
+ var zb0512 int
+ zb0512, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- if zb0493 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0493), uint64(maxBitmaskSize))
+ if zb0512 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0512), uint64(maxBitmaskSize))
return
}
- zb0492, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0511, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0492)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0511)
}
case "lnbs":
- var zb0494 int
- var zb0495 bool
- zb0494, zb0495, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0513 int
+ var zb0514 bool
+ zb0513, zb0514, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0494 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0494), uint64(maxEncodedTransactionGroups))
+ if zb0513 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0513), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0495 {
+ if zb0514 {
(*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0494 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0494]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0513 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0513]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0494)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0513)
}
- for zb0033 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumByteSlice", zb0033)
+ err = msgp.WrapError(err, "LocalNumByteSlice", zb0034)
return
}
}
case "lnbsbm":
{
- var zb0496 []byte
- var zb0497 int
- zb0497, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0515 []byte
+ var zb0516 int
+ zb0516, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- if zb0497 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0497), uint64(maxBitmaskSize))
+ if zb0516 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0516), uint64(maxBitmaskSize))
return
}
- zb0496, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0515, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0496)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0515)
}
case "gnui":
- var zb0498 int
- var zb0499 bool
- zb0498, zb0499, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0517 int
+ var zb0518 bool
+ zb0517, zb0518, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0498 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0498), uint64(maxEncodedTransactionGroups))
+ if zb0517 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0517), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0499 {
+ if zb0518 {
(*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0498 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0498]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0517 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0517]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0498)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0517)
}
- for zb0034 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumUint", zb0034)
+ err = msgp.WrapError(err, "GlobalNumUint", zb0035)
return
}
}
case "gnuibm":
{
- var zb0500 []byte
- var zb0501 int
- zb0501, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0519 []byte
+ var zb0520 int
+ zb0520, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- if zb0501 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0501), uint64(maxBitmaskSize))
+ if zb0520 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0520), uint64(maxBitmaskSize))
return
}
- zb0500, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0519, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0500)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0519)
}
case "gnbs":
- var zb0502 int
- var zb0503 bool
- zb0502, zb0503, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0521 int
+ var zb0522 bool
+ zb0521, zb0522, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0502 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0502), uint64(maxEncodedTransactionGroups))
+ if zb0521 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0521), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0503 {
+ if zb0522 {
(*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0502 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0502]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0521 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0521]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0502)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0521)
}
- for zb0035 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumByteSlice", zb0035)
+ err = msgp.WrapError(err, "GlobalNumByteSlice", zb0036)
return
}
}
case "gnbsbm":
{
- var zb0504 []byte
- var zb0505 int
- zb0505, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0523 []byte
+ var zb0524 int
+ zb0524, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- if zb0505 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0505), uint64(maxBitmaskSize))
+ if zb0524 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0524), uint64(maxBitmaskSize))
return
}
- zb0504, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0523, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0504)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0523)
}
case "apap":
- var zb0506 int
- var zb0507 bool
- zb0506, zb0507, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0525 int
+ var zb0526 bool
+ zb0525, zb0526, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0506 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0506), uint64(maxEncodedTransactionGroups))
+ if zb0525 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0525), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0507 {
+ if zb0526 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0506 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0506]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0525 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0525]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0506)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0525)
}
- for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0508 []byte
- var zb0509 int
- zb0509, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0527 []byte
+ var zb0528 int
+ zb0528, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0037)
return
}
- if zb0509 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0509), uint64(config.MaxAvailableAppProgramLen))
+ if zb0528 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0528), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0508, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ zb0527, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0037)
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036] = program(zb0508)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037] = program(zb0527)
}
}
case "apapbm":
{
- var zb0510 []byte
- var zb0511 int
- zb0511, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0529 []byte
+ var zb0530 int
+ zb0530, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- if zb0511 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0511), uint64(maxBitmaskSize))
+ if zb0530 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0530), uint64(maxBitmaskSize))
return
}
- zb0510, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0529, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0510)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0529)
}
case "apsu":
- var zb0512 int
- var zb0513 bool
- zb0512, zb0513, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0531 int
+ var zb0532 bool
+ zb0531, zb0532, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0512 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0512), uint64(maxEncodedTransactionGroups))
+ if zb0531 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0531), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0513 {
+ if zb0532 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0512 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0512]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0531 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0531]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0512)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0531)
}
- for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0514 []byte
- var zb0515 int
- zb0515, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0533 []byte
+ var zb0534 int
+ zb0534, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0038)
return
}
- if zb0515 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0515), uint64(config.MaxAvailableAppProgramLen))
+ if zb0534 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0534), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0514, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ zb0533, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0038)
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037] = program(zb0514)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038] = program(zb0533)
}
}
case "apsubm":
{
- var zb0516 []byte
- var zb0517 int
- zb0517, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0535 []byte
+ var zb0536 int
+ zb0536, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- if zb0517 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0517), uint64(maxBitmaskSize))
+ if zb0536 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0536), uint64(maxBitmaskSize))
return
}
- zb0516, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0535, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0516)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0535)
}
case "apep":
- var zb0518 int
- var zb0519 bool
- zb0518, zb0519, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0537 int
+ var zb0538 bool
+ zb0537, zb0538, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0518 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0518), uint64(maxEncodedTransactionGroups))
+ if zb0537 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0537), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0519 {
+ if zb0538 {
(*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0518 {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0518]
+ } else if (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0537 {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0537]
} else {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0518)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0537)
}
- for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0039 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ExtraProgramPages", zb0038)
+ err = msgp.WrapError(err, "ExtraProgramPages", zb0039)
return
}
}
case "apepbm":
{
- var zb0520 []byte
- var zb0521 int
- zb0521, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0539 []byte
+ var zb0540 int
+ zb0540, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- if zb0521 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0521), uint64(maxBitmaskSize))
+ if zb0540 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0540), uint64(maxBitmaskSize))
return
}
- zb0520, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0539, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0520)
+ (*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0539)
}
case "certrnd":
- var zb0522 int
- var zb0523 bool
- zb0522, zb0523, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0541 int
+ var zb0542 bool
+ zb0541, zb0542, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0522 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0522), uint64(maxEncodedTransactionGroups))
+ if zb0541 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0541), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0523 {
+ if zb0542 {
(*z).encodedTxns.encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0522 {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0522]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0541 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0541]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0522)
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0541)
}
- for zb0039 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertRound", zb0039)
+ err = msgp.WrapError(err, "CertRound", zb0040)
return
}
}
case "certrndbm":
{
- var zb0524 []byte
- var zb0525 int
- zb0525, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0543 []byte
+ var zb0544 int
+ zb0544, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- if zb0525 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0525), uint64(maxBitmaskSize))
+ if zb0544 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0544), uint64(maxBitmaskSize))
return
}
- zb0524, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0543, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0524)
+ (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0543)
}
case "certtype":
- var zb0526 int
- var zb0527 bool
- zb0526, zb0527, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0545 int
+ var zb0546 bool
+ zb0545, zb0546, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertType")
return
}
- if zb0526 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0526), uint64(maxEncodedTransactionGroups))
+ if zb0545 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0545), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertType")
return
}
- if zb0527 {
+ if zb0546 {
(*z).encodedTxns.encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0526 {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0526]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0545 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0545]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0526)
+ (*z).encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0545)
}
- for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].UnmarshalMsg(bts)
+ for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertType", zb0040)
+ err = msgp.WrapError(err, "CertType", zb0041)
return
}
}
case "certtypebm":
{
- var zb0528 []byte
- var zb0529 int
- zb0529, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0547 []byte
+ var zb0548 int
+ zb0548, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- if zb0529 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0529), uint64(maxBitmaskSize))
+ if zb0548 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0548), uint64(maxBitmaskSize))
return
}
- zb0528, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
+ zb0547, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0528)
+ (*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0547)
}
case "certc":
- var zb0530 int
- zb0530, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0549 int
+ var zb0550 bool
+ zb0549, zb0550, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigCommit")
return
}
- if zb0530 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0530), uint64(maxAddressBytes))
- return
- }
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0549 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0549), uint64(maxAddressBytes))
err = msgp.WrapError(err, "SigCommit")
return
}
+ if zb0550 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0549 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0549]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0549)
+ }
+ for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigCommit", zb0042)
+ return
+ }
+ }
case "certcbm":
{
- var zb0531 []byte
- var zb0532 int
- zb0532, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0551 []byte
+ var zb0552 int
+ zb0552, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- if zb0532 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0532), uint64(maxBitmaskSize))
+ if zb0552 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0552), uint64(maxBitmaskSize))
return
}
- zb0531, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0551, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0531)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0551)
}
case "certw":
- var zb0533 int
- var zb0534 bool
- zb0533, zb0534, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0553 int
+ var zb0554 bool
+ zb0553, zb0554, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0533 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0533), uint64(maxEncodedTransactionGroups))
+ if zb0553 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0553), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0534 {
+ if zb0554 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0533 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0533]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0553 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0553]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0533)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0553)
}
- for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SignedWeight", zb0041)
+ err = msgp.WrapError(err, "SignedWeight", zb0043)
return
}
}
case "certwbm":
{
- var zb0535 []byte
- var zb0536 int
- zb0536, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0555 []byte
+ var zb0556 int
+ zb0556, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- if zb0536 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0536), uint64(maxBitmaskSize))
+ if zb0556 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0556), uint64(maxBitmaskSize))
return
}
- zb0535, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0555, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0535)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0555)
}
case "certS":
- var zb0537 int
- var zb0538 bool
- zb0537, zb0538, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0557 int
+ var zb0558 bool
+ zb0557, zb0558, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0537 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0537), uint64(maxEncodedTransactionGroups))
+ if zb0557 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0557), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0538 {
+ if zb0558 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0537 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0537]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0557 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0557]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0537)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0557)
}
- for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0539 int
- var zb0540 bool
- zb0539, zb0540, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0559 int
+ var zb0560 bool
+ zb0559, zb0560, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0042)
+ err = msgp.WrapError(err, "SigProofs", zb0044)
return
}
- if zb0539 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0539), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs", zb0042)
+ if zb0559 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0559), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "SigProofs", zb0044)
return
}
- if zb0540 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042]) >= zb0539 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])[:zb0539]
+ if zb0560 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044]) >= zb0559 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])[:zb0559]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = make(certProofs, zb0539)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = make(certProofs, zb0559)
}
- for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].UnmarshalMsg(bts)
+ for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0042, zb0043)
+ err = msgp.WrapError(err, "SigProofs", zb0044, zb0045)
return
}
}
}
case "certSbm":
{
- var zb0541 []byte
- var zb0542 int
- zb0542, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0561 []byte
+ var zb0562 int
+ zb0562, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- if zb0542 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0542), uint64(maxBitmaskSize))
+ if zb0562 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0562), uint64(maxBitmaskSize))
return
}
- zb0541, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0561, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0541)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0561)
+ }
+ case "certSH":
+ var zb0563 int
+ var zb0564 bool
+ zb0563, zb0564, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0563 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0563), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0564 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0563 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0563]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0563)
+ }
+ for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes", zb0046)
+ return
+ }
+ }
+ case "certSHbm":
+ {
+ var zb0565 []byte
+ var zb0566 int
+ zb0566, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ if zb0566 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0566), uint64(maxBitmaskSize))
+ return
+ }
+ zb0565, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0565)
}
case "certP":
- var zb0543 int
- var zb0544 bool
- zb0543, zb0544, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0567 int
+ var zb0568 bool
+ zb0567, zb0568, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0543 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0543), uint64(maxEncodedTransactionGroups))
+ if zb0567 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0567), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0544 {
+ if zb0568 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0543 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0543]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0567 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0567]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0543)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0567)
}
- for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0545 int
- var zb0546 bool
- zb0545, zb0546, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0047 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0569 int
+ var zb0570 bool
+ zb0569, zb0570, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0044)
+ err = msgp.WrapError(err, "PartProofs", zb0047)
return
}
- if zb0545 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0545), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs", zb0044)
+ if zb0569 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0569), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "PartProofs", zb0047)
return
}
- if zb0546 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044]) >= zb0545 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])[:zb0545]
+ if zb0570 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047]) >= zb0569 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])[:zb0569]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = make(certProofs, zb0545)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = make(certProofs, zb0569)
}
- for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].UnmarshalMsg(bts)
+ for zb0048 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ bts, err = (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0044, zb0045)
+ err = msgp.WrapError(err, "PartProofs", zb0047, zb0048)
return
}
}
}
case "certPbm":
{
- var zb0547 []byte
- var zb0548 int
- zb0548, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0571 []byte
+ var zb0572 int
+ zb0572, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- if zb0548 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0548), uint64(maxBitmaskSize))
+ if zb0572 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0572), uint64(maxBitmaskSize))
return
}
- zb0547, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0571, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0547)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0571)
+ }
+ case "certPH":
+ var zb0573 int
+ var zb0574 bool
+ zb0573, zb0574, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0573 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0573), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0574 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0573 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0573]
+ } else {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0573)
+ }
+ for zb0049 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes", zb0049)
+ return
+ }
+ }
+ case "certPHbm":
+ {
+ var zb0575 []byte
+ var zb0576 int
+ zb0576, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ if zb0576 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0576), uint64(maxBitmaskSize))
+ return
+ }
+ zb0575, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0575)
}
case "certr":
- var zb0549 int
- var zb0550 bool
- zb0549, zb0550, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0577 int
+ var zb0578 bool
+ zb0577, zb0578, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0549 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0549), uint64(maxEncodedTransactionGroups))
+ if zb0577 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0577), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0550 {
+ if zb0578 {
(*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0549 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0549]
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0577 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0577]
} else {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0549)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0577)
}
- for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0551 int
- var zb0552 bool
- zb0551, zb0552, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0050 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0579 int
+ var zb0580 bool
+ zb0579, zb0580, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046)
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- if zb0551 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0551), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "Reveals", zb0046)
+ if zb0579 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0579), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- if zb0552 {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = nil
- } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = make(revealMap, zb0551)
+ if zb0580 {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = nil
+ } else if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = make(revealMap, zb0579)
}
- for zb0551 > 0 {
- var zb0047 uint64
- var zb0048 compactcert.Reveal
- zb0551--
- zb0047, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0579 > 0 {
+ var zb0051 uint64
+ var zb0052 compactcert.Reveal
+ zb0579--
+ zb0051, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046)
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- bts, err = zb0048.UnmarshalMsg(bts)
+ bts, err = zb0052.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046, zb0047)
+ err = msgp.WrapError(err, "Reveals", zb0050, zb0051)
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047] = zb0048
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051] = zb0052
}
}
case "certrbm":
{
- var zb0553 []byte
- var zb0554 int
- zb0554, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0581 []byte
+ var zb0582 int
+ zb0582, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- if zb0554 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0554), uint64(maxBitmaskSize))
+ if zb0582 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0582), uint64(maxBitmaskSize))
return
}
- zb0553, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0581, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0553)
+ (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0581)
}
default:
err = msgp.ErrNoField(string(field))
@@ -18096,104 +19159,108 @@ func (z *encodedSignedTxns) Msgsize() (s int) {
for zb0011 := range (*z).encodedTxns.encodedKeyregTxnFields.VoteLast {
s += (*z).encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].Msgsize()
}
- s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation)) + 4 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
- for zb0013 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
- s += (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0013].Msgsize()
+ s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot) * (msgp.BoolSize)) + 5 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot) + 4 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
+ for zb0014 := range (*z).encodedTxns.encodedPaymentTxnFields.Amount {
+ s += (*z).encodedTxns.encodedPaymentTxnFields.Amount[zb0014].Msgsize()
}
s += 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount)) + 6 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo)) + 5 + msgp.ArrayHeaderSize
- for zb0014 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- s += (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].Msgsize()
+ for zb0015 := range (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ s += (*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset)) + 2 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) * (msgp.Uint64Size)) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal)) + 3 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) * (msgp.Uint32Size)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen)) + 3 + msgp.ArrayHeaderSize
- for zb0017 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017])
+ for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName)) + 3 + msgp.ArrayHeaderSize
- for zb0018 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018])
+ for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName)) + 3 + msgp.ArrayHeaderSize
- for zb0019 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019])
+ for zb0020 := range (*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ s += msgp.StringPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL)) + 3 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash)) + 2 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager)) + 2 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve)) + 2 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze)) + 2 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback)) + 5 + msgp.ArrayHeaderSize
- for zb0020 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- s += (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].Msgsize()
+ for zb0021 := range (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ s += (*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount)) + 5 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender)) + 5 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver)) + 7 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo)) + 5 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount)) + 5 + msgp.ArrayHeaderSize
- for zb0022 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- s += (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].Msgsize()
+ for zb0023 := range (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ s += (*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen)) + 5 + msgp.ArrayHeaderSize
- for zb0023 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- s += (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].Msgsize()
+ for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ s += (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID)) + 5 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion)) + 5 + msgp.ArrayHeaderSize
- for zb0024 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
s += msgp.ArrayHeaderSize
- for zb0025 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- s += msgp.BytesPrefixSize + len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ s += msgp.BytesPrefixSize + len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs)) + 5 + msgp.ArrayHeaderSize
- for zb0026 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts {
s += msgp.ArrayHeaderSize
- for zb0027 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- s += (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].Msgsize()
+ for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ s += (*z).encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts)) + 5 + msgp.ArrayHeaderSize
- for zb0028 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
s += msgp.ArrayHeaderSize
- for zb0029 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- s += (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].Msgsize()
+ for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ s += (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps)) + 5 + msgp.ArrayHeaderSize
- for zb0030 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
s += msgp.ArrayHeaderSize
- for zb0031 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- s += (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].Msgsize()
+ for zb0032 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ s += (*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice)) + 5 + msgp.ArrayHeaderSize
- for zb0036 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram)) + 5 + msgp.ArrayHeaderSize
- for zb0037 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ for zb0038 := range (*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) * (msgp.Uint32Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages)) + 8 + msgp.ArrayHeaderSize
- for zb0039 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
- s += (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].Msgsize()
+ for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertRound {
+ s += (*z).encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].Msgsize()
}
s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound)) + 9 + msgp.ArrayHeaderSize
- for zb0040 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
- s += (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].Msgsize()
+ for zb0041 := range (*z).encodedTxns.encodedCompactCertTxnFields.CertType {
+ s += (*z).encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].Msgsize()
}
- s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.BytesPrefixSize + len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
- for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.ArrayHeaderSize
+ for zb0042 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ s += (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].Msgsize()
+ }
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
+ for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
s += msgp.ArrayHeaderSize
- for zb0043 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- s += (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].Msgsize()
+ for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ s += (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0044 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0047 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
s += msgp.ArrayHeaderSize
- for zb0045 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- s += (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].Msgsize()
+ for zb0048 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ s += (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0046 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0050 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
s += msgp.MapHeaderSize
- if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] != nil {
- for zb0047, zb0048 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] {
- _ = zb0047
- _ = zb0048
- s += 0 + msgp.Uint64Size + zb0048.Msgsize()
+ if (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] != nil {
+ for zb0051, zb0052 := range (*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] {
+ _ = zb0051
+ _ = zb0052
+ s += 0 + msgp.Uint64Size + zb0052.Msgsize()
}
}
}
@@ -18203,7 +19270,7 @@ func (z *encodedSignedTxns) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *encodedSignedTxns) MsgIsZero() bool {
- return (len((*z).Sig) == 0) && (len((*z).BitmaskSig) == 0) && (len((*z).encodedMsigs.Version) == 0) && (len((*z).encodedMsigs.BitmaskVersion) == 0) && (len((*z).encodedMsigs.Threshold) == 0) && (len((*z).encodedMsigs.BitmaskThreshold) == 0) && (len((*z).encodedMsigs.Subsigs) == 0) && (len((*z).encodedMsigs.BitmaskSubsigs) == 0) && (len((*z).encodedLsigs.Logic) == 0) && (len((*z).encodedLsigs.BitmaskLogic) == 0) && (len((*z).encodedLsigs.LogicArgs) == 0) && (len((*z).encodedLsigs.BitmaskLogicArgs) == 0) && (len((*z).AuthAddr) == 0) && (len((*z).BitmaskAuthAddr) == 0) && (len((*z).encodedTxns.TxType) == 0) && (len((*z).encodedTxns.BitmaskTxType) == 0) && ((*z).encodedTxns.TxTypeOffset == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Sender) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Fee) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Note) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Lease) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
+ return (len((*z).Sig) == 0) && (len((*z).BitmaskSig) == 0) && (len((*z).encodedMsigs.Version) == 0) && (len((*z).encodedMsigs.BitmaskVersion) == 0) && (len((*z).encodedMsigs.Threshold) == 0) && (len((*z).encodedMsigs.BitmaskThreshold) == 0) && (len((*z).encodedMsigs.Subsigs) == 0) && (len((*z).encodedMsigs.BitmaskSubsigs) == 0) && (len((*z).encodedLsigs.Logic) == 0) && (len((*z).encodedLsigs.BitmaskLogic) == 0) && (len((*z).encodedLsigs.LogicArgs) == 0) && (len((*z).encodedLsigs.BitmaskLogicArgs) == 0) && (len((*z).AuthAddr) == 0) && (len((*z).BitmaskAuthAddr) == 0) && (len((*z).encodedTxns.TxType) == 0) && (len((*z).encodedTxns.BitmaskTxType) == 0) && ((*z).encodedTxns.TxTypeOffset == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Sender) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Fee) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Note) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.Lease) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.HasValidRoot) == 0) && (len((*z).encodedTxns.encodedKeyregTxnFields.CommitmentRoot) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
@@ -19205,460 +20272,484 @@ func (z *encodedTxnHeaders) MsgIsZero() bool {
func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0044Len := uint32(112)
- var zb0044Mask [2]uint64 /* 123 bits */
+ zb0048Len := uint32(118)
+ var zb0048Mask [3]uint64 /* 129 bits */
if len((*z).encodedAssetTransferTxnFields.AssetAmount) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x800
+ zb0048Len--
+ zb0048Mask[0] |= 0x800
}
if len((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x1000
+ zb0048Len--
+ zb0048Mask[0] |= 0x1000
}
if len((*z).encodedAssetTransferTxnFields.AssetCloseTo) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x2000
+ zb0048Len--
+ zb0048Mask[0] |= 0x2000
}
if len((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x4000
+ zb0048Len--
+ zb0048Mask[0] |= 0x4000
}
if len((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x8000
+ zb0048Len--
+ zb0048Mask[0] |= 0x8000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x10000
+ zb0048Len--
+ zb0048Mask[0] |= 0x10000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x20000
+ zb0048Len--
+ zb0048Mask[0] |= 0x20000
}
if len((*z).encodedPaymentTxnFields.Amount) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x40000
+ zb0048Len--
+ zb0048Mask[0] |= 0x40000
}
if len((*z).encodedPaymentTxnFields.BitmaskAmount) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x80000
+ zb0048Len--
+ zb0048Mask[0] |= 0x80000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x100000
+ zb0048Len--
+ zb0048Mask[0] |= 0x100000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x200000
+ zb0048Len--
+ zb0048Mask[0] |= 0x200000
}
if len((*z).encodedApplicationCallTxnFields.ApplicationArgs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x400000
+ zb0048Len--
+ zb0048Mask[0] |= 0x400000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x800000
+ zb0048Len--
+ zb0048Mask[0] |= 0x800000
}
if len((*z).encodedApplicationCallTxnFields.OnCompletion) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x1000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x1000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x2000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x2000000
}
if len((*z).encodedApplicationCallTxnFields.ApprovalProgram) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x4000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x4000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x8000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x8000000
}
if len((*z).encodedApplicationCallTxnFields.ForeignAssets) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x10000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x10000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x20000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x20000000
}
if len((*z).encodedApplicationCallTxnFields.Accounts) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x40000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x40000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskAccounts) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x80000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x80000000
}
if len((*z).encodedApplicationCallTxnFields.ExtraProgramPages) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x100000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x100000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x200000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x200000000
}
if len((*z).encodedApplicationCallTxnFields.ForeignApps) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x400000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x400000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskForeignApps) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x800000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x800000000
}
if len((*z).encodedApplicationCallTxnFields.ApplicationID) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x1000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x1000000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskApplicationID) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x2000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x2000000000
}
if len((*z).encodedApplicationCallTxnFields.ClearStateProgram) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x4000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x4000000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x8000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x8000000000
}
if len((*z).encodedAssetTransferTxnFields.AssetReceiver) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x10000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x10000000000
}
if len((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x20000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x20000000000
}
if len((*z).encodedAssetTransferTxnFields.AssetSender) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x40000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x40000000000
}
if len((*z).encodedAssetTransferTxnFields.BitmaskAssetSender) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x80000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x80000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x100000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x100000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x200000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x200000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x400000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x400000000000
}
if len((*z).encodedAssetConfigTxnFields.ConfigAsset) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x800000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x800000000000
}
if len((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x1000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x1000000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x2000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x2000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x4000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x4000000000000
+ }
+ if len((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0 {
+ zb0048Len--
+ zb0048Mask[0] |= 0x8000000000000
+ }
+ if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0 {
+ zb0048Len--
+ zb0048Mask[0] |= 0x10000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x8000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x20000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x10000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x40000000000000
+ }
+ if len((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0 {
+ zb0048Len--
+ zb0048Mask[0] |= 0x80000000000000
+ }
+ if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0 {
+ zb0048Len--
+ zb0048Mask[0] |= 0x100000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x20000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x200000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x40000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x400000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x80000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x800000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.Reveals) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x100000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x1000000000000000
}
if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x200000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x2000000000000000
}
if len((*z).encodedCompactCertTxnFields.CertRound) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x400000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x4000000000000000
}
if len((*z).encodedCompactCertTxnFields.BitmaskCertRound) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x800000000000000
+ zb0048Len--
+ zb0048Mask[0] |= 0x8000000000000000
}
if len((*z).encodedCompactCertTxnFields.CertType) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x1000000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x1
}
if len((*z).encodedCompactCertTxnFields.BitmaskCertType) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x2000000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x2
}
if len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x4000000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x4
}
if len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0 {
- zb0044Len--
- zb0044Mask[0] |= 0x8000000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x8
}
if len((*z).encodedPaymentTxnFields.CloseRemainderTo) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x1
+ zb0048Len--
+ zb0048Mask[1] |= 0x10
}
if len((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x2
+ zb0048Len--
+ zb0048Mask[1] |= 0x20
+ }
+ if len((*z).encodedKeyregTxnFields.CommitmentRoot) == 0 {
+ zb0048Len--
+ zb0048Mask[1] |= 0x40
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x4
+ zb0048Len--
+ zb0048Mask[1] |= 0x80
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x8
+ zb0048Len--
+ zb0048Mask[1] |= 0x100
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x10
+ zb0048Len--
+ zb0048Mask[1] |= 0x200
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x20
+ zb0048Len--
+ zb0048Mask[1] |= 0x400
}
if len((*z).encodedAssetFreezeTxnFields.FreezeAccount) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x40
+ zb0048Len--
+ zb0048Mask[1] |= 0x800
}
if len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x80
+ zb0048Len--
+ zb0048Mask[1] |= 0x1000
}
if len((*z).encodedAssetFreezeTxnFields.FreezeAsset) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x100
+ zb0048Len--
+ zb0048Mask[1] |= 0x2000
}
if len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x200
+ zb0048Len--
+ zb0048Mask[1] |= 0x4000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x400
+ zb0048Len--
+ zb0048Mask[1] |= 0x8000
}
if len((*z).encodedTxnHeaders.Fee) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x800
+ zb0048Len--
+ zb0048Mask[1] |= 0x10000
}
if len((*z).encodedTxnHeaders.BitmaskFee) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x1000
+ zb0048Len--
+ zb0048Mask[1] |= 0x20000
}
if len((*z).encodedTxnHeaders.FirstValid) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x2000
+ zb0048Len--
+ zb0048Mask[1] |= 0x40000
}
if len((*z).encodedTxnHeaders.BitmaskFirstValid) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x4000
+ zb0048Len--
+ zb0048Mask[1] |= 0x80000
}
if len((*z).encodedTxnHeaders.BitmaskGenesisID) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x8000
+ zb0048Len--
+ zb0048Mask[1] |= 0x100000
}
if len((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x10000
+ zb0048Len--
+ zb0048Mask[1] |= 0x200000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x20000
+ zb0048Len--
+ zb0048Mask[1] |= 0x400000
}
if len((*z).encodedApplicationCallTxnFields.GlobalNumUint) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x40000
+ zb0048Len--
+ zb0048Mask[1] |= 0x800000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x80000
+ zb0048Len--
+ zb0048Mask[1] |= 0x1000000
}
if len((*z).encodedTxnHeaders.BitmaskGroup) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x100000
+ zb0048Len--
+ zb0048Mask[1] |= 0x2000000
}
if len((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x200000
+ zb0048Len--
+ zb0048Mask[1] |= 0x4000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x400000
+ zb0048Len--
+ zb0048Mask[1] |= 0x8000000
}
if len((*z).encodedApplicationCallTxnFields.LocalNumUint) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x800000
+ zb0048Len--
+ zb0048Mask[1] |= 0x10000000
}
if len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x1000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x20000000
}
if len((*z).encodedTxnHeaders.LastValid) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x2000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x40000000
}
if len((*z).encodedTxnHeaders.BitmaskLastValid) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x4000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x80000000
}
if len((*z).encodedTxnHeaders.Lease) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x8000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x100000000
}
if len((*z).encodedTxnHeaders.BitmaskLease) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x10000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x200000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x20000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x400000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x40000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x800000000
}
if len((*z).encodedKeyregTxnFields.BitmaskNonparticipation) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x80000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x1000000000
}
if len((*z).encodedTxnHeaders.Note) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x100000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x2000000000
}
if len((*z).encodedTxnHeaders.BitmaskNote) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x200000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x4000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x400000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x8000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x800000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x10000000000
}
if len((*z).encodedPaymentTxnFields.Receiver) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x1000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x20000000000
}
if len((*z).encodedPaymentTxnFields.BitmaskReceiver) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x2000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x40000000000
}
if len((*z).encodedTxnHeaders.RekeyTo) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x4000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x80000000000
}
if len((*z).encodedTxnHeaders.BitmaskRekeyTo) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x8000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x100000000000
}
if len((*z).encodedKeyregTxnFields.SelectionPK) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x10000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x200000000000
}
if len((*z).encodedTxnHeaders.Sender) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x20000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x400000000000
}
if len((*z).encodedTxnHeaders.BitmaskSender) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x40000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x800000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x80000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x1000000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x100000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x2000000000000
}
if len((*z).TxType) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x200000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x4000000000000
}
if len((*z).BitmaskTxType) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x400000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x8000000000000
}
if (*z).TxTypeOffset == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x800000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x10000000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x1000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x20000000000000
}
if len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x2000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x40000000000000
+ }
+ if len((*z).encodedKeyregTxnFields.HasValidRoot) == 0 {
+ zb0048Len--
+ zb0048Mask[1] |= 0x80000000000000
}
if len((*z).encodedKeyregTxnFields.VoteFirst) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x4000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x100000000000000
}
if len((*z).encodedKeyregTxnFields.BitmaskVoteFirst) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x8000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x200000000000000
}
if len((*z).encodedKeyregTxnFields.BitmaskKeys) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x10000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x400000000000000
}
if len((*z).encodedKeyregTxnFields.VoteKeyDilution) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x20000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x800000000000000
}
if len((*z).encodedKeyregTxnFields.VotePK) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x40000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x1000000000000000
}
if len((*z).encodedKeyregTxnFields.VoteLast) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x80000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x2000000000000000
}
if len((*z).encodedKeyregTxnFields.BitmaskVoteLast) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x100000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x4000000000000000
}
if len((*z).encodedAssetTransferTxnFields.XferAsset) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x200000000000000
+ zb0048Len--
+ zb0048Mask[1] |= 0x8000000000000000
}
if len((*z).encodedAssetTransferTxnFields.BitmaskXferAsset) == 0 {
- zb0044Len--
- zb0044Mask[1] |= 0x400000000000000
+ zb0048Len--
+ zb0048Mask[2] |= 0x1
}
- // variable map header, size zb0044Len
- o = msgp.AppendMapHeader(o, zb0044Len)
- if zb0044Len != 0 {
- if (zb0044Mask[0] & 0x800) == 0 { // if not empty
+ // variable map header, size zb0048Len
+ o = msgp.AppendMapHeader(o, zb0048Len)
+ if zb0048Len != 0 {
+ if (zb0048Mask[0] & 0x800) == 0 { // if not empty
// string "aamt"
o = append(o, 0xa4, 0x61, 0x61, 0x6d, 0x74)
if (*z).encodedAssetTransferTxnFields.AssetAmount == nil {
@@ -19666,41 +20757,41 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetTransferTxnFields.AssetAmount)))
}
- for zb0016 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
- o = msgp.AppendUint64(o, (*z).encodedAssetTransferTxnFields.AssetAmount[zb0016])
+ for zb0017 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
+ o = msgp.AppendUint64(o, (*z).encodedAssetTransferTxnFields.AssetAmount[zb0017])
}
}
- if (zb0044Mask[0] & 0x1000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x1000) == 0 { // if not empty
// string "aamtbm"
o = append(o, 0xa6, 0x61, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount))
}
- if (zb0044Mask[0] & 0x2000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x2000) == 0 { // if not empty
// string "aclose"
o = append(o, 0xa6, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedAssetTransferTxnFields.AssetCloseTo)
}
- if (zb0044Mask[0] & 0x4000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x4000) == 0 { // if not empty
// string "aclosebm"
o = append(o, 0xa8, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
}
- if (zb0044Mask[0] & 0x8000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x8000) == 0 { // if not empty
// string "afrzbm"
o = append(o, 0xa6, 0x61, 0x66, 0x72, 0x7a, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
}
- if (zb0044Mask[0] & 0x10000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x10000) == 0 { // if not empty
// string "am"
o = append(o, 0xa2, 0x61, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
}
- if (zb0044Mask[0] & 0x20000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x20000) == 0 { // if not empty
// string "ambm"
o = append(o, 0xa4, 0x61, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
}
- if (zb0044Mask[0] & 0x40000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x40000) == 0 { // if not empty
// string "amt"
o = append(o, 0xa3, 0x61, 0x6d, 0x74)
if (*z).encodedPaymentTxnFields.Amount == nil {
@@ -19708,16 +20799,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedPaymentTxnFields.Amount)))
}
- for zb0008 := range (*z).encodedPaymentTxnFields.Amount {
- o = (*z).encodedPaymentTxnFields.Amount[zb0008].MarshalMsg(o)
+ for zb0009 := range (*z).encodedPaymentTxnFields.Amount {
+ o = (*z).encodedPaymentTxnFields.Amount[zb0009].MarshalMsg(o)
}
}
- if (zb0044Mask[0] & 0x80000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x80000) == 0 { // if not empty
// string "amtbm"
o = append(o, 0xa5, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedPaymentTxnFields.BitmaskAmount))
}
- if (zb0044Mask[0] & 0x100000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x100000) == 0 { // if not empty
// string "an"
o = append(o, 0xa2, 0x61, 0x6e)
if (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName == nil {
@@ -19725,16 +20816,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName)))
}
- for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0013])
+ for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0014])
}
}
- if (zb0044Mask[0] & 0x200000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x200000) == 0 { // if not empty
// string "anbm"
o = append(o, 0xa4, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
}
- if (zb0044Mask[0] & 0x400000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x400000) == 0 { // if not empty
// string "apaa"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x61)
if (*z).encodedApplicationCallTxnFields.ApplicationArgs == nil {
@@ -19742,33 +20833,33 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ApplicationArgs)))
}
- for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
- if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] == nil {
+ for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
+ if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020])))
}
- for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] {
- o = msgp.AppendBytes(o, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020])
+ for zb0021 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] {
+ o = msgp.AppendBytes(o, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021])
}
}
}
- if (zb0044Mask[0] & 0x800000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x800000) == 0 { // if not empty
// string "apaabm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs))
}
- if (zb0044Mask[0] & 0x1000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x1000000) == 0 { // if not empty
// string "apan"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x6e)
o = msgp.AppendBytes(o, (*z).encodedApplicationCallTxnFields.OnCompletion)
}
- if (zb0044Mask[0] & 0x2000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x2000000) == 0 { // if not empty
// string "apanbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion))
}
- if (zb0044Mask[0] & 0x4000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x4000000) == 0 { // if not empty
// string "apap"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x70)
if (*z).encodedApplicationCallTxnFields.ApprovalProgram == nil {
@@ -19776,16 +20867,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ApprovalProgram)))
}
- for zb0031 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031]))
+ for zb0032 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032]))
}
}
- if (zb0044Mask[0] & 0x8000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x8000000) == 0 { // if not empty
// string "apapbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram))
}
- if (zb0044Mask[0] & 0x10000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x10000000) == 0 { // if not empty
// string "apas"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x73)
if (*z).encodedApplicationCallTxnFields.ForeignAssets == nil {
@@ -19793,23 +20884,23 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignAssets)))
}
- for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
- if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] == nil {
+ for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
+ if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026])))
}
- for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] {
- o = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025][zb0026].MarshalMsg(o)
+ for zb0027 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] {
+ o = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026][zb0027].MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x20000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x20000000) == 0 { // if not empty
// string "apasbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets))
}
- if (zb0044Mask[0] & 0x40000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x40000000) == 0 { // if not empty
// string "apat"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x74)
if (*z).encodedApplicationCallTxnFields.Accounts == nil {
@@ -19817,23 +20908,23 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.Accounts)))
}
- for zb0021 := range (*z).encodedApplicationCallTxnFields.Accounts {
- if (*z).encodedApplicationCallTxnFields.Accounts[zb0021] == nil {
+ for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts {
+ if (*z).encodedApplicationCallTxnFields.Accounts[zb0022] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.Accounts[zb0021])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.Accounts[zb0022])))
}
- for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0021] {
- o = (*z).encodedApplicationCallTxnFields.Accounts[zb0021][zb0022].MarshalMsg(o)
+ for zb0023 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0022] {
+ o = (*z).encodedApplicationCallTxnFields.Accounts[zb0022][zb0023].MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x80000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x80000000) == 0 { // if not empty
// string "apatbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts))
}
- if (zb0044Mask[0] & 0x100000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x100000000) == 0 { // if not empty
// string "apep"
o = append(o, 0xa4, 0x61, 0x70, 0x65, 0x70)
if (*z).encodedApplicationCallTxnFields.ExtraProgramPages == nil {
@@ -19841,16 +20932,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ExtraProgramPages)))
}
- for zb0033 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
- o = msgp.AppendUint32(o, (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0033])
+ for zb0034 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
+ o = msgp.AppendUint32(o, (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0034])
}
}
- if (zb0044Mask[0] & 0x200000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x200000000) == 0 { // if not empty
// string "apepbm"
o = append(o, 0xa6, 0x61, 0x70, 0x65, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
}
- if (zb0044Mask[0] & 0x400000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x400000000) == 0 { // if not empty
// string "apfa"
o = append(o, 0xa4, 0x61, 0x70, 0x66, 0x61)
if (*z).encodedApplicationCallTxnFields.ForeignApps == nil {
@@ -19858,23 +20949,23 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignApps)))
}
- for zb0023 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
- if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] == nil {
+ for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
+ if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignApps[zb0023])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ForeignApps[zb0024])))
}
- for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] {
- o = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023][zb0024].MarshalMsg(o)
+ for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] {
+ o = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024][zb0025].MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x800000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x800000000) == 0 { // if not empty
// string "apfabm"
o = append(o, 0xa6, 0x61, 0x70, 0x66, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps))
}
- if (zb0044Mask[0] & 0x1000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x1000000000) == 0 { // if not empty
// string "apid"
o = append(o, 0xa4, 0x61, 0x70, 0x69, 0x64)
if (*z).encodedApplicationCallTxnFields.ApplicationID == nil {
@@ -19882,16 +20973,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ApplicationID)))
}
- for zb0018 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
- o = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0018].MarshalMsg(o)
+ for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
+ o = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0019].MarshalMsg(o)
}
}
- if (zb0044Mask[0] & 0x2000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x2000000000) == 0 { // if not empty
// string "apidbm"
o = append(o, 0xa6, 0x61, 0x70, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID))
}
- if (zb0044Mask[0] & 0x4000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x4000000000) == 0 { // if not empty
// string "apsu"
o = append(o, 0xa4, 0x61, 0x70, 0x73, 0x75)
if (*z).encodedApplicationCallTxnFields.ClearStateProgram == nil {
@@ -19899,36 +20990,36 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.ClearStateProgram)))
}
- for zb0032 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032]))
+ for zb0033 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033]))
}
}
- if (zb0044Mask[0] & 0x8000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x8000000000) == 0 { // if not empty
// string "apsubm"
o = append(o, 0xa6, 0x61, 0x70, 0x73, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram))
}
- if (zb0044Mask[0] & 0x10000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x10000000000) == 0 { // if not empty
// string "arcv"
o = append(o, 0xa4, 0x61, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedAssetTransferTxnFields.AssetReceiver)
}
- if (zb0044Mask[0] & 0x20000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x20000000000) == 0 { // if not empty
// string "arcvbm"
o = append(o, 0xa6, 0x61, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver))
}
- if (zb0044Mask[0] & 0x40000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x40000000000) == 0 { // if not empty
// string "asnd"
o = append(o, 0xa4, 0x61, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedAssetTransferTxnFields.AssetSender)
}
- if (zb0044Mask[0] & 0x80000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x80000000000) == 0 { // if not empty
// string "asndbm"
o = append(o, 0xa6, 0x61, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender))
}
- if (zb0044Mask[0] & 0x100000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x100000000000) == 0 { // if not empty
// string "au"
o = append(o, 0xa2, 0x61, 0x75)
if (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL == nil {
@@ -19936,21 +21027,21 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL)))
}
- for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
- o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0014])
+ for zb0015 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0015])
}
}
- if (zb0044Mask[0] & 0x200000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x200000000000) == 0 { // if not empty
// string "aubm"
o = append(o, 0xa4, 0x61, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
}
- if (zb0044Mask[0] & 0x400000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x400000000000) == 0 { // if not empty
// string "c"
o = append(o, 0xa1, 0x63)
o = msgp.AppendBytes(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
}
- if (zb0044Mask[0] & 0x800000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x800000000000) == 0 { // if not empty
// string "caid"
o = append(o, 0xa4, 0x63, 0x61, 0x69, 0x64)
if (*z).encodedAssetConfigTxnFields.ConfigAsset == nil {
@@ -19958,21 +21049,21 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.ConfigAsset)))
}
- for zb0009 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
- o = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0009].MarshalMsg(o)
+ for zb0010 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
+ o = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0010].MarshalMsg(o)
}
}
- if (zb0044Mask[0] & 0x1000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x1000000000000) == 0 { // if not empty
// string "caidbm"
o = append(o, 0xa6, 0x63, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset))
}
- if (zb0044Mask[0] & 0x2000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x2000000000000) == 0 { // if not empty
// string "cbm"
o = append(o, 0xa3, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
}
- if (zb0044Mask[0] & 0x4000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x4000000000000) == 0 { // if not empty
// string "certP"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x50)
if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs == nil {
@@ -19980,23 +21071,40 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs)))
}
- for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
- if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] == nil {
+ for zb0042 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
+ if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042])))
}
- for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] {
- o = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039][zb0040].MarshalMsg(o)
+ for zb0043 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] {
+ o = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042][zb0043].MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x8000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x8000000000000) == 0 { // if not empty
+ // string "certPH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48)
+ if (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)))
+ }
+ for zb0044 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0044])
+ }
+ }
+ if (zb0048Mask[0] & 0x10000000000000) == 0 { // if not empty
+ // string "certPHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ }
+ if (zb0048Mask[0] & 0x20000000000000) == 0 { // if not empty
// string "certPbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x50, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
}
- if (zb0044Mask[0] & 0x10000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x40000000000000) == 0 { // if not empty
// string "certS"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x53)
if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs == nil {
@@ -20004,33 +21112,57 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs)))
}
- for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
- if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] == nil {
+ for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
+ if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039])))
}
- for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] {
- o = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037][zb0038].MarshalMsg(o)
+ for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] {
+ o = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039][zb0040].MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x20000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x80000000000000) == 0 { // if not empty
+ // string "certSH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48)
+ if (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)))
+ }
+ for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0041])
+ }
+ }
+ if (zb0048Mask[0] & 0x100000000000000) == 0 { // if not empty
+ // string "certSHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ }
+ if (zb0048Mask[0] & 0x200000000000000) == 0 { // if not empty
// string "certSbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x53, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
}
- if (zb0044Mask[0] & 0x40000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x400000000000000) == 0 { // if not empty
// string "certc"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x63)
- o = msgp.AppendBytes(o, (*z).encodedCompactCertTxnFields.encodedCert.SigCommit)
+ if (*z).encodedCompactCertTxnFields.encodedCert.SigCommit == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SigCommit)))
+ }
+ for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigCommit {
+ o = (*z).encodedCompactCertTxnFields.encodedCert.SigCommit[zb0037].MarshalMsg(o)
+ }
}
- if (zb0044Mask[0] & 0x80000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x800000000000000) == 0 { // if not empty
// string "certcbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
}
- if (zb0044Mask[0] & 0x100000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x1000000000000000) == 0 { // if not empty
// string "certr"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x72)
if (*z).encodedCompactCertTxnFields.encodedCert.Reveals == nil {
@@ -20038,31 +21170,31 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.Reveals)))
}
- for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
- if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] == nil {
+ for zb0045 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
+ if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041])))
+ o = msgp.AppendMapHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045])))
}
- zb0042_keys := make([]uint64, 0, len((*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041]))
- for zb0042 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] {
- zb0042_keys = append(zb0042_keys, zb0042)
+ zb0046_keys := make([]uint64, 0, len((*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045]))
+ for zb0046 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] {
+ zb0046_keys = append(zb0046_keys, zb0046)
}
- sort.Sort(SortUint64(zb0042_keys))
- for _, zb0042 := range zb0042_keys {
- zb0043 := (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041][zb0042]
- _ = zb0043
- o = msgp.AppendUint64(o, zb0042)
- o = zb0043.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0046_keys))
+ for _, zb0046 := range zb0046_keys {
+ zb0047 := (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045][zb0046]
+ _ = zb0047
+ o = msgp.AppendUint64(o, zb0046)
+ o = zb0047.MarshalMsg(o)
}
}
}
- if (zb0044Mask[0] & 0x200000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x2000000000000000) == 0 { // if not empty
// string "certrbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
}
- if (zb0044Mask[0] & 0x400000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x4000000000000000) == 0 { // if not empty
// string "certrnd"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64)
if (*z).encodedCompactCertTxnFields.CertRound == nil {
@@ -20070,16 +21202,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.CertRound)))
}
- for zb0034 := range (*z).encodedCompactCertTxnFields.CertRound {
- o = (*z).encodedCompactCertTxnFields.CertRound[zb0034].MarshalMsg(o)
+ for zb0035 := range (*z).encodedCompactCertTxnFields.CertRound {
+ o = (*z).encodedCompactCertTxnFields.CertRound[zb0035].MarshalMsg(o)
}
}
- if (zb0044Mask[0] & 0x800000000000000) == 0 { // if not empty
+ if (zb0048Mask[0] & 0x8000000000000000) == 0 { // if not empty
// string "certrndbm"
o = append(o, 0xa9, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.BitmaskCertRound))
}
- if (zb0044Mask[0] & 0x1000000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1) == 0 { // if not empty
// string "certtype"
o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65)
if (*z).encodedCompactCertTxnFields.CertType == nil {
@@ -20087,16 +21219,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.CertType)))
}
- for zb0035 := range (*z).encodedCompactCertTxnFields.CertType {
- o = (*z).encodedCompactCertTxnFields.CertType[zb0035].MarshalMsg(o)
+ for zb0036 := range (*z).encodedCompactCertTxnFields.CertType {
+ o = (*z).encodedCompactCertTxnFields.CertType[zb0036].MarshalMsg(o)
}
}
- if (zb0044Mask[0] & 0x2000000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2) == 0 { // if not empty
// string "certtypebm"
o = append(o, 0xaa, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.BitmaskCertType))
}
- if (zb0044Mask[0] & 0x4000000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4) == 0 { // if not empty
// string "certw"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x77)
if (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight == nil {
@@ -20104,26 +21236,31 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight)))
}
- for zb0036 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
- o = msgp.AppendUint64(o, (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0036])
+ for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ o = msgp.AppendUint64(o, (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0038])
}
}
- if (zb0044Mask[0] & 0x8000000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8) == 0 { // if not empty
// string "certwbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x77, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
}
- if (zb0044Mask[1] & 0x1) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x10) == 0 { // if not empty
// string "close"
o = append(o, 0xa5, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedPaymentTxnFields.CloseRemainderTo)
}
- if (zb0044Mask[1] & 0x2) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x20) == 0 { // if not empty
// string "closebm"
o = append(o, 0xa7, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo))
}
- if (zb0044Mask[1] & 0x4) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x40) == 0 { // if not empty
+ // string "comt"
+ o = append(o, 0xa4, 0x63, 0x6f, 0x6d, 0x74)
+ o = msgp.AppendBytes(o, (*z).encodedKeyregTxnFields.CommitmentRoot)
+ }
+ if (zb0048Mask[1] & 0x80) == 0 { // if not empty
// string "dc"
o = append(o, 0xa2, 0x64, 0x63)
if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals == nil {
@@ -20131,36 +21268,36 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals)))
}
- for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- o = msgp.AppendUint32(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0011])
+ for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ o = msgp.AppendUint32(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0012])
}
}
- if (zb0044Mask[1] & 0x8) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x100) == 0 { // if not empty
// string "dcbm"
o = append(o, 0xa4, 0x64, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
}
- if (zb0044Mask[1] & 0x10) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x200) == 0 { // if not empty
// string "dfbm"
o = append(o, 0xa4, 0x64, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
}
- if (zb0044Mask[1] & 0x20) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x400) == 0 { // if not empty
// string "f"
o = append(o, 0xa1, 0x66)
o = msgp.AppendBytes(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
}
- if (zb0044Mask[1] & 0x40) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x800) == 0 { // if not empty
// string "fadd"
o = append(o, 0xa4, 0x66, 0x61, 0x64, 0x64)
o = msgp.AppendBytes(o, (*z).encodedAssetFreezeTxnFields.FreezeAccount)
}
- if (zb0044Mask[1] & 0x80) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1000) == 0 { // if not empty
// string "faddbm"
o = append(o, 0xa6, 0x66, 0x61, 0x64, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
}
- if (zb0044Mask[1] & 0x100) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2000) == 0 { // if not empty
// string "faid"
o = append(o, 0xa4, 0x66, 0x61, 0x69, 0x64)
if (*z).encodedAssetFreezeTxnFields.FreezeAsset == nil {
@@ -20168,21 +21305,21 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetFreezeTxnFields.FreezeAsset)))
}
- for zb0017 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
- o = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0017].MarshalMsg(o)
+ for zb0018 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
+ o = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0018].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x200) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4000) == 0 { // if not empty
// string "faidbm"
o = append(o, 0xa6, 0x66, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
}
- if (zb0044Mask[1] & 0x400) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8000) == 0 { // if not empty
// string "fbm"
o = append(o, 0xa3, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
}
- if (zb0044Mask[1] & 0x800) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x10000) == 0 { // if not empty
// string "fee"
o = append(o, 0xa3, 0x66, 0x65, 0x65)
if (*z).encodedTxnHeaders.Fee == nil {
@@ -20194,12 +21331,12 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxnHeaders.Fee[zb0001].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x1000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x20000) == 0 { // if not empty
// string "feebm"
o = append(o, 0xa5, 0x66, 0x65, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskFee))
}
- if (zb0044Mask[1] & 0x2000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x40000) == 0 { // if not empty
// string "fv"
o = append(o, 0xa2, 0x66, 0x76)
if (*z).encodedTxnHeaders.FirstValid == nil {
@@ -20211,17 +21348,17 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxnHeaders.FirstValid[zb0002].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x4000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x80000) == 0 { // if not empty
// string "fvbm"
o = append(o, 0xa4, 0x66, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskFirstValid))
}
- if (zb0044Mask[1] & 0x8000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x100000) == 0 { // if not empty
// string "genbm"
o = append(o, 0xa5, 0x67, 0x65, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskGenesisID))
}
- if (zb0044Mask[1] & 0x10000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x200000) == 0 { // if not empty
// string "gnbs"
o = append(o, 0xa4, 0x67, 0x6e, 0x62, 0x73)
if (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice == nil {
@@ -20229,16 +21366,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice)))
}
- for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0030])
+ for zb0031 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0031])
}
}
- if (zb0044Mask[1] & 0x20000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x400000) == 0 { // if not empty
// string "gnbsbm"
o = append(o, 0xa6, 0x67, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
}
- if (zb0044Mask[1] & 0x40000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x800000) == 0 { // if not empty
// string "gnui"
o = append(o, 0xa4, 0x67, 0x6e, 0x75, 0x69)
if (*z).encodedApplicationCallTxnFields.GlobalNumUint == nil {
@@ -20246,21 +21383,21 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.GlobalNumUint)))
}
- for zb0029 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0029])
+ for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0030])
}
}
- if (zb0044Mask[1] & 0x80000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1000000) == 0 { // if not empty
// string "gnuibm"
o = append(o, 0xa6, 0x67, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
}
- if (zb0044Mask[1] & 0x100000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2000000) == 0 { // if not empty
// string "grpbm"
o = append(o, 0xa5, 0x67, 0x72, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskGroup))
}
- if (zb0044Mask[1] & 0x200000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4000000) == 0 { // if not empty
// string "lnbs"
o = append(o, 0xa4, 0x6c, 0x6e, 0x62, 0x73)
if (*z).encodedApplicationCallTxnFields.LocalNumByteSlice == nil {
@@ -20268,16 +21405,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.LocalNumByteSlice)))
}
- for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0028])
+ for zb0029 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0029])
}
}
- if (zb0044Mask[1] & 0x400000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8000000) == 0 { // if not empty
// string "lnbsbm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
}
- if (zb0044Mask[1] & 0x800000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x10000000) == 0 { // if not empty
// string "lnui"
o = append(o, 0xa4, 0x6c, 0x6e, 0x75, 0x69)
if (*z).encodedApplicationCallTxnFields.LocalNumUint == nil {
@@ -20285,16 +21422,16 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedApplicationCallTxnFields.LocalNumUint)))
}
- for zb0027 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0027])
+ for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0028])
}
}
- if (zb0044Mask[1] & 0x1000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x20000000) == 0 { // if not empty
// string "lnuibm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint))
}
- if (zb0044Mask[1] & 0x2000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x40000000) == 0 { // if not empty
// string "lv"
o = append(o, 0xa2, 0x6c, 0x76)
if (*z).encodedTxnHeaders.LastValid == nil {
@@ -20306,37 +21443,37 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedTxnHeaders.LastValid[zb0003].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x4000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x80000000) == 0 { // if not empty
// string "lvbm"
o = append(o, 0xa4, 0x6c, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskLastValid))
}
- if (zb0044Mask[1] & 0x8000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x100000000) == 0 { // if not empty
// string "lx"
o = append(o, 0xa2, 0x6c, 0x78)
o = msgp.AppendBytes(o, (*z).encodedTxnHeaders.Lease)
}
- if (zb0044Mask[1] & 0x10000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x200000000) == 0 { // if not empty
// string "lxbm"
o = append(o, 0xa4, 0x6c, 0x78, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskLease))
}
- if (zb0044Mask[1] & 0x20000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x400000000) == 0 { // if not empty
// string "m"
o = append(o, 0xa1, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager)
}
- if (zb0044Mask[1] & 0x40000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x800000000) == 0 { // if not empty
// string "mbm"
o = append(o, 0xa3, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
}
- if (zb0044Mask[1] & 0x80000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1000000000) == 0 { // if not empty
// string "nonpartbm"
o = append(o, 0xa9, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation))
}
- if (zb0044Mask[1] & 0x100000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2000000000) == 0 { // if not empty
// string "note"
o = append(o, 0xa4, 0x6e, 0x6f, 0x74, 0x65)
if (*z).encodedTxnHeaders.Note == nil {
@@ -20348,57 +21485,57 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendBytes(o, (*z).encodedTxnHeaders.Note[zb0004])
}
}
- if (zb0044Mask[1] & 0x200000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4000000000) == 0 { // if not empty
// string "notebm"
o = append(o, 0xa6, 0x6e, 0x6f, 0x74, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskNote))
}
- if (zb0044Mask[1] & 0x400000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8000000000) == 0 { // if not empty
// string "r"
o = append(o, 0xa1, 0x72)
o = msgp.AppendBytes(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
}
- if (zb0044Mask[1] & 0x800000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x10000000000) == 0 { // if not empty
// string "rbm"
o = append(o, 0xa3, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
}
- if (zb0044Mask[1] & 0x1000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x20000000000) == 0 { // if not empty
// string "rcv"
o = append(o, 0xa3, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedPaymentTxnFields.Receiver)
}
- if (zb0044Mask[1] & 0x2000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x40000000000) == 0 { // if not empty
// string "rcvbm"
o = append(o, 0xa5, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedPaymentTxnFields.BitmaskReceiver))
}
- if (zb0044Mask[1] & 0x4000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x80000000000) == 0 { // if not empty
// string "rekey"
o = append(o, 0xa5, 0x72, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedTxnHeaders.RekeyTo)
}
- if (zb0044Mask[1] & 0x8000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x100000000000) == 0 { // if not empty
// string "rekeybm"
o = append(o, 0xa7, 0x72, 0x65, 0x6b, 0x65, 0x79, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskRekeyTo))
}
- if (zb0044Mask[1] & 0x10000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x200000000000) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedKeyregTxnFields.SelectionPK)
}
- if (zb0044Mask[1] & 0x20000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x400000000000) == 0 { // if not empty
// string "snd"
o = append(o, 0xa3, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedTxnHeaders.Sender)
}
- if (zb0044Mask[1] & 0x40000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x800000000000) == 0 { // if not empty
// string "sndbm"
o = append(o, 0xa5, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedTxnHeaders.BitmaskSender))
}
- if (zb0044Mask[1] & 0x80000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1000000000000) == 0 { // if not empty
// string "t"
o = append(o, 0xa1, 0x74)
if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total == nil {
@@ -20406,31 +21543,31 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total)))
}
- for zb0010 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
- o = msgp.AppendUint64(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0010])
+ for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ o = msgp.AppendUint64(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0011])
}
}
- if (zb0044Mask[1] & 0x100000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2000000000000) == 0 { // if not empty
// string "tbm"
o = append(o, 0xa3, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
}
- if (zb0044Mask[1] & 0x200000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4000000000000) == 0 { // if not empty
// string "type"
o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
o = msgp.AppendBytes(o, (*z).TxType)
}
- if (zb0044Mask[1] & 0x400000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8000000000000) == 0 { // if not empty
// string "typebm"
o = append(o, 0xa6, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).BitmaskTxType))
}
- if (zb0044Mask[1] & 0x800000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x10000000000000) == 0 { // if not empty
// string "typeo"
o = append(o, 0xa5, 0x74, 0x79, 0x70, 0x65, 0x6f)
o = msgp.AppendByte(o, (*z).TxTypeOffset)
}
- if (zb0044Mask[1] & 0x1000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x20000000000000) == 0 { // if not empty
// string "un"
o = append(o, 0xa2, 0x75, 0x6e)
if (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName == nil {
@@ -20438,16 +21575,28 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName)))
}
- for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0012])
+ for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ o = msgp.AppendString(o, (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0013])
}
}
- if (zb0044Mask[1] & 0x2000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x40000000000000) == 0 { // if not empty
// string "unbm"
o = append(o, 0xa4, 0x75, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
}
- if (zb0044Mask[1] & 0x4000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x80000000000000) == 0 { // if not empty
+ // string "vldrt"
+ o = append(o, 0xa5, 0x76, 0x6c, 0x64, 0x72, 0x74)
+ if (*z).encodedKeyregTxnFields.HasValidRoot == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedKeyregTxnFields.HasValidRoot)))
+ }
+ for zb0008 := range (*z).encodedKeyregTxnFields.HasValidRoot {
+ o = msgp.AppendBool(o, (*z).encodedKeyregTxnFields.HasValidRoot[zb0008])
+ }
+ }
+ if (zb0048Mask[1] & 0x100000000000000) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
if (*z).encodedKeyregTxnFields.VoteFirst == nil {
@@ -20459,17 +21608,17 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedKeyregTxnFields.VoteFirst[zb0005].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x8000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x200000000000000) == 0 { // if not empty
// string "votefstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedKeyregTxnFields.BitmaskVoteFirst))
}
- if (zb0044Mask[1] & 0x10000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x400000000000000) == 0 { // if not empty
// string "votekbm"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedKeyregTxnFields.BitmaskKeys))
}
- if (zb0044Mask[1] & 0x20000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x800000000000000) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
if (*z).encodedKeyregTxnFields.VoteKeyDilution == nil {
@@ -20481,12 +21630,12 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).encodedKeyregTxnFields.VoteKeyDilution[zb0007])
}
}
- if (zb0044Mask[1] & 0x40000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x1000000000000000) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedKeyregTxnFields.VotePK)
}
- if (zb0044Mask[1] & 0x80000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x2000000000000000) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
if (*z).encodedKeyregTxnFields.VoteLast == nil {
@@ -20498,12 +21647,12 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedKeyregTxnFields.VoteLast[zb0006].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x100000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x4000000000000000) == 0 { // if not empty
// string "votelstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedKeyregTxnFields.BitmaskVoteLast))
}
- if (zb0044Mask[1] & 0x200000000000000) == 0 { // if not empty
+ if (zb0048Mask[1] & 0x8000000000000000) == 0 { // if not empty
// string "xaid"
o = append(o, 0xa4, 0x78, 0x61, 0x69, 0x64)
if (*z).encodedAssetTransferTxnFields.XferAsset == nil {
@@ -20511,11 +21660,11 @@ func (z *encodedTxns) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedAssetTransferTxnFields.XferAsset)))
}
- for zb0015 := range (*z).encodedAssetTransferTxnFields.XferAsset {
- o = (*z).encodedAssetTransferTxnFields.XferAsset[zb0015].MarshalMsg(o)
+ for zb0016 := range (*z).encodedAssetTransferTxnFields.XferAsset {
+ o = (*z).encodedAssetTransferTxnFields.XferAsset[zb0016].MarshalMsg(o)
}
}
- if (zb0044Mask[1] & 0x400000000000000) == 0 { // if not empty
+ if (zb0048Mask[2] & 0x1) == 0 { // if not empty
// string "xaidbm"
o = append(o, 0xa6, 0x78, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset))
@@ -20533,25 +21682,25 @@ func (_ *encodedTxns) CanMarshalMsg(z interface{}) bool {
func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0044 int
- var zb0045 bool
- zb0044, zb0045, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0048 int
+ var zb0049 bool
+ zb0048, zb0049, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0044, zb0045, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0048, zb0049, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0044 > 0 {
- zb0044--
- var zb0046 int
- zb0046, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0050 int
+ zb0050, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxType")
return
}
- if zb0046 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0046), uint64(maxEncodedTransactionGroups))
+ if zb0050 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0050), uint64(maxEncodedTransactionGroups))
return
}
(*z).TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).TxType)
@@ -20560,46 +21709,46 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0047 []byte
- var zb0048 int
- zb0048, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0051 []byte
+ var zb0052 int
+ zb0052, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- if zb0048 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0048), uint64(maxBitmaskSize))
+ if zb0052 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0052), uint64(maxBitmaskSize))
return
}
- zb0047, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskTxType))
+ zb0051, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- (*z).BitmaskTxType = bitmask(zb0047)
+ (*z).BitmaskTxType = bitmask(zb0051)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
(*z).TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxTypeOffset")
return
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0049 int
- zb0049, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0053 int
+ zb0053, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Sender")
return
}
- if zb0049 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0049), uint64(maxAddressBytes))
+ if zb0053 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0053), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Sender)
@@ -20608,48 +21757,48 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0050 []byte
- var zb0051 int
- zb0051, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0054 []byte
+ var zb0055 int
+ zb0055, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- if zb0051 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0051), uint64(maxBitmaskSize))
+ if zb0055 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0055), uint64(maxBitmaskSize))
return
}
- zb0050, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskSender))
+ zb0054, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- (*z).encodedTxnHeaders.BitmaskSender = bitmask(zb0050)
+ (*z).encodedTxnHeaders.BitmaskSender = bitmask(zb0054)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0052 int
- var zb0053 bool
- zb0052, zb0053, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0056 int
+ var zb0057 bool
+ zb0056, zb0057, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0052 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0052), uint64(maxEncodedTransactionGroups))
+ if zb0056 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0056), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0053 {
+ if zb0057 {
(*z).encodedTxnHeaders.Fee = nil
- } else if (*z).encodedTxnHeaders.Fee != nil && cap((*z).encodedTxnHeaders.Fee) >= zb0052 {
- (*z).encodedTxnHeaders.Fee = ((*z).encodedTxnHeaders.Fee)[:zb0052]
+ } else if (*z).encodedTxnHeaders.Fee != nil && cap((*z).encodedTxnHeaders.Fee) >= zb0056 {
+ (*z).encodedTxnHeaders.Fee = ((*z).encodedTxnHeaders.Fee)[:zb0056]
} else {
- (*z).encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0052)
+ (*z).encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0056)
}
for zb0001 := range (*z).encodedTxnHeaders.Fee {
bts, err = (*z).encodedTxnHeaders.Fee[zb0001].UnmarshalMsg(bts)
@@ -20659,48 +21808,48 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0054 []byte
- var zb0055 int
- zb0055, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0058 []byte
+ var zb0059 int
+ zb0059, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- if zb0055 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0055), uint64(maxBitmaskSize))
+ if zb0059 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0059), uint64(maxBitmaskSize))
return
}
- zb0054, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFee))
+ zb0058, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- (*z).encodedTxnHeaders.BitmaskFee = bitmask(zb0054)
+ (*z).encodedTxnHeaders.BitmaskFee = bitmask(zb0058)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0056 int
- var zb0057 bool
- zb0056, zb0057, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0060 int
+ var zb0061 bool
+ zb0060, zb0061, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0056 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0056), uint64(maxEncodedTransactionGroups))
+ if zb0060 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0060), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0057 {
+ if zb0061 {
(*z).encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxnHeaders.FirstValid) >= zb0056 {
- (*z).encodedTxnHeaders.FirstValid = ((*z).encodedTxnHeaders.FirstValid)[:zb0056]
+ } else if (*z).encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxnHeaders.FirstValid) >= zb0060 {
+ (*z).encodedTxnHeaders.FirstValid = ((*z).encodedTxnHeaders.FirstValid)[:zb0060]
} else {
- (*z).encodedTxnHeaders.FirstValid = make([]basics.Round, zb0056)
+ (*z).encodedTxnHeaders.FirstValid = make([]basics.Round, zb0060)
}
for zb0002 := range (*z).encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedTxnHeaders.FirstValid[zb0002].UnmarshalMsg(bts)
@@ -20710,48 +21859,48 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0058 []byte
- var zb0059 int
- zb0059, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0062 []byte
+ var zb0063 int
+ zb0063, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- if zb0059 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0059), uint64(maxBitmaskSize))
+ if zb0063 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0063), uint64(maxBitmaskSize))
return
}
- zb0058, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFirstValid))
+ zb0062, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- (*z).encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0058)
+ (*z).encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0062)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0060 int
- var zb0061 bool
- zb0060, zb0061, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0064 int
+ var zb0065 bool
+ zb0064, zb0065, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0060 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0060), uint64(maxEncodedTransactionGroups))
+ if zb0064 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0064), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0061 {
+ if zb0065 {
(*z).encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxnHeaders.LastValid) >= zb0060 {
- (*z).encodedTxnHeaders.LastValid = ((*z).encodedTxnHeaders.LastValid)[:zb0060]
+ } else if (*z).encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxnHeaders.LastValid) >= zb0064 {
+ (*z).encodedTxnHeaders.LastValid = ((*z).encodedTxnHeaders.LastValid)[:zb0064]
} else {
- (*z).encodedTxnHeaders.LastValid = make([]basics.Round, zb0060)
+ (*z).encodedTxnHeaders.LastValid = make([]basics.Round, zb0064)
}
for zb0003 := range (*z).encodedTxnHeaders.LastValid {
bts, err = (*z).encodedTxnHeaders.LastValid[zb0003].UnmarshalMsg(bts)
@@ -20761,58 +21910,58 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0062 []byte
- var zb0063 int
- zb0063, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0066 []byte
+ var zb0067 int
+ zb0067, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- if zb0063 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0063), uint64(maxBitmaskSize))
+ if zb0067 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0067), uint64(maxBitmaskSize))
return
}
- zb0062, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLastValid))
+ zb0066, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- (*z).encodedTxnHeaders.BitmaskLastValid = bitmask(zb0062)
+ (*z).encodedTxnHeaders.BitmaskLastValid = bitmask(zb0066)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0064 int
- var zb0065 bool
- zb0064, zb0065, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0068 int
+ var zb0069 bool
+ zb0068, zb0069, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0064 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0064), uint64(maxEncodedTransactionGroups))
+ if zb0068 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0068), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0065 {
+ if zb0069 {
(*z).encodedTxnHeaders.Note = nil
- } else if (*z).encodedTxnHeaders.Note != nil && cap((*z).encodedTxnHeaders.Note) >= zb0064 {
- (*z).encodedTxnHeaders.Note = ((*z).encodedTxnHeaders.Note)[:zb0064]
+ } else if (*z).encodedTxnHeaders.Note != nil && cap((*z).encodedTxnHeaders.Note) >= zb0068 {
+ (*z).encodedTxnHeaders.Note = ((*z).encodedTxnHeaders.Note)[:zb0068]
} else {
- (*z).encodedTxnHeaders.Note = make([][]byte, zb0064)
+ (*z).encodedTxnHeaders.Note = make([][]byte, zb0068)
}
for zb0004 := range (*z).encodedTxnHeaders.Note {
- var zb0066 int
- zb0066, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0070 int
+ zb0070, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note", zb0004)
return
}
- if zb0066 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0066), uint64(config.MaxTxnNoteBytes))
+ if zb0070 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0070), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedTxnHeaders.Note[zb0004], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Note[zb0004])
@@ -20822,82 +21971,82 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0067 []byte
- var zb0068 int
- zb0068, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0071 []byte
+ var zb0072 int
+ zb0072, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- if zb0068 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0068), uint64(maxBitmaskSize))
+ if zb0072 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0072), uint64(maxBitmaskSize))
return
}
- zb0067, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskNote))
+ zb0071, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- (*z).encodedTxnHeaders.BitmaskNote = bitmask(zb0067)
+ (*z).encodedTxnHeaders.BitmaskNote = bitmask(zb0071)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0069 []byte
- var zb0070 int
- zb0070, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0073 []byte
+ var zb0074 int
+ zb0074, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- if zb0070 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0070), uint64(maxBitmaskSize))
+ if zb0074 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0074), uint64(maxBitmaskSize))
return
}
- zb0069, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGenesisID))
+ zb0073, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- (*z).encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0069)
+ (*z).encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0073)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0071 []byte
- var zb0072 int
- zb0072, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0075 []byte
+ var zb0076 int
+ zb0076, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- if zb0072 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0072), uint64(maxBitmaskSize))
+ if zb0076 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0076), uint64(maxBitmaskSize))
return
}
- zb0071, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGroup))
+ zb0075, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- (*z).encodedTxnHeaders.BitmaskGroup = bitmask(zb0071)
+ (*z).encodedTxnHeaders.BitmaskGroup = bitmask(zb0075)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0073 int
- zb0073, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0077 int
+ zb0077, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Lease")
return
}
- if zb0073 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0073), uint64(maxAddressBytes))
+ if zb0077 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0077), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Lease)
@@ -20906,38 +22055,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0074 []byte
- var zb0075 int
- zb0075, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0078 []byte
+ var zb0079 int
+ zb0079, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- if zb0075 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0075), uint64(maxBitmaskSize))
+ if zb0079 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0079), uint64(maxBitmaskSize))
return
}
- zb0074, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLease))
+ zb0078, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- (*z).encodedTxnHeaders.BitmaskLease = bitmask(zb0074)
+ (*z).encodedTxnHeaders.BitmaskLease = bitmask(zb0078)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0076 int
- zb0076, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0080 int
+ zb0080, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "RekeyTo")
return
}
- if zb0076 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0076), uint64(maxAddressBytes))
+ if zb0080 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0080), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.RekeyTo)
@@ -20946,38 +22095,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0077 []byte
- var zb0078 int
- zb0078, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0081 []byte
+ var zb0082 int
+ zb0082, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- if zb0078 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0078), uint64(maxBitmaskSize))
+ if zb0082 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0082), uint64(maxBitmaskSize))
return
}
- zb0077, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskRekeyTo))
+ zb0081, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- (*z).encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0077)
+ (*z).encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0081)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0079 int
- zb0079, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0083 int
+ zb0083, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VotePK")
return
}
- if zb0079 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0079), uint64(maxAddressBytes))
+ if zb0083 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0083), uint64(maxAddressBytes))
return
}
(*z).encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.VotePK)
@@ -20986,16 +22135,16 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0080 int
- zb0080, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0084 int
+ zb0084, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SelectionPK")
return
}
- if zb0080 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0080), uint64(maxAddressBytes))
+ if zb0084 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0084), uint64(maxAddressBytes))
return
}
(*z).encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.SelectionPK)
@@ -21004,26 +22153,26 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0081 int
- var zb0082 bool
- zb0081, zb0082, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0085 int
+ var zb0086 bool
+ zb0085, zb0086, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0081 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0081), uint64(maxEncodedTransactionGroups))
+ if zb0085 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0085), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0082 {
+ if zb0086 {
(*z).encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedKeyregTxnFields.VoteFirst) >= zb0081 {
- (*z).encodedKeyregTxnFields.VoteFirst = ((*z).encodedKeyregTxnFields.VoteFirst)[:zb0081]
+ } else if (*z).encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedKeyregTxnFields.VoteFirst) >= zb0085 {
+ (*z).encodedKeyregTxnFields.VoteFirst = ((*z).encodedKeyregTxnFields.VoteFirst)[:zb0085]
} else {
- (*z).encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0081)
+ (*z).encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0085)
}
for zb0005 := range (*z).encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedKeyregTxnFields.VoteFirst[zb0005].UnmarshalMsg(bts)
@@ -21033,48 +22182,48 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0083 []byte
- var zb0084 int
- zb0084, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0087 []byte
+ var zb0088 int
+ zb0088, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- if zb0084 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0084), uint64(maxBitmaskSize))
+ if zb0088 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0088), uint64(maxBitmaskSize))
return
}
- zb0083, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0087, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- (*z).encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0083)
+ (*z).encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0087)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0085 int
- var zb0086 bool
- zb0085, zb0086, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0089 int
+ var zb0090 bool
+ zb0089, zb0090, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0085 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0085), uint64(maxEncodedTransactionGroups))
+ if zb0089 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0089), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0086 {
+ if zb0090 {
(*z).encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedKeyregTxnFields.VoteLast) >= zb0085 {
- (*z).encodedKeyregTxnFields.VoteLast = ((*z).encodedKeyregTxnFields.VoteLast)[:zb0085]
+ } else if (*z).encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedKeyregTxnFields.VoteLast) >= zb0089 {
+ (*z).encodedKeyregTxnFields.VoteLast = ((*z).encodedKeyregTxnFields.VoteLast)[:zb0089]
} else {
- (*z).encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0085)
+ (*z).encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0089)
}
for zb0006 := range (*z).encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedKeyregTxnFields.VoteLast[zb0006].UnmarshalMsg(bts)
@@ -21084,48 +22233,48 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0087 []byte
- var zb0088 int
- zb0088, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0091 []byte
+ var zb0092 int
+ zb0092, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- if zb0088 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0088), uint64(maxBitmaskSize))
+ if zb0092 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0092), uint64(maxBitmaskSize))
return
}
- zb0087, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0091, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- (*z).encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0087)
+ (*z).encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0091)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0089 int
- var zb0090 bool
- zb0089, zb0090, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0093 int
+ var zb0094 bool
+ zb0093, zb0094, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0089 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0089), uint64(maxEncodedTransactionGroups))
+ if zb0093 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0093), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0090 {
+ if zb0094 {
(*z).encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedKeyregTxnFields.VoteKeyDilution) >= zb0089 {
- (*z).encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedKeyregTxnFields.VoteKeyDilution)[:zb0089]
+ } else if (*z).encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedKeyregTxnFields.VoteKeyDilution) >= zb0093 {
+ (*z).encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedKeyregTxnFields.VoteKeyDilution)[:zb0093]
} else {
- (*z).encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0089)
+ (*z).encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0093)
}
for zb0007 := range (*z).encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedKeyregTxnFields.VoteKeyDilution[zb0007], bts, err = msgp.ReadUint64Bytes(bts)
@@ -21135,60 +22284,107 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0091 []byte
- var zb0092 int
- zb0092, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0095 []byte
+ var zb0096 int
+ zb0096, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- if zb0092 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0092), uint64(maxBitmaskSize))
+ if zb0096 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0096), uint64(maxBitmaskSize))
return
}
- zb0091, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskKeys))
+ zb0095, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- (*z).encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0091)
+ (*z).encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0095)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0093 []byte
- var zb0094 int
- zb0094, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0097 []byte
+ var zb0098 int
+ zb0098, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- if zb0094 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0094), uint64(maxBitmaskSize))
+ if zb0098 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0098), uint64(maxBitmaskSize))
return
}
- zb0093, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0097, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- (*z).encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0093)
+ (*z).encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0097)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0095 int
- zb0095, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0099 int
+ var zb0100 bool
+ zb0099, zb0100, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0099 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0099), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0100 {
+ (*z).encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedKeyregTxnFields.HasValidRoot) >= zb0099 {
+ (*z).encodedKeyregTxnFields.HasValidRoot = ((*z).encodedKeyregTxnFields.HasValidRoot)[:zb0099]
+ } else {
+ (*z).encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0099)
+ }
+ for zb0008 := range (*z).encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedKeyregTxnFields.HasValidRoot[zb0008], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot", zb0008)
+ return
+ }
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ var zb0101 int
+ zb0101, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ if zb0101 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0101), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ var zb0102 int
+ zb0102, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Receiver")
return
}
- if zb0095 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0095), uint64(maxAddressBytes))
+ if zb0102 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0102), uint64(maxAddressBytes))
return
}
(*z).encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedPaymentTxnFields.Receiver)
@@ -21197,89 +22393,89 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0096 []byte
- var zb0097 int
- zb0097, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0103 []byte
+ var zb0104 int
+ zb0104, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- if zb0097 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0097), uint64(maxBitmaskSize))
+ if zb0104 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0104), uint64(maxBitmaskSize))
return
}
- zb0096, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskReceiver))
+ zb0103, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- (*z).encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0096)
+ (*z).encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0103)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0098 int
- var zb0099 bool
- zb0098, zb0099, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0105 int
+ var zb0106 bool
+ zb0105, zb0106, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0098 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0098), uint64(maxEncodedTransactionGroups))
+ if zb0105 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0105), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0099 {
+ if zb0106 {
(*z).encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedPaymentTxnFields.Amount != nil && cap((*z).encodedPaymentTxnFields.Amount) >= zb0098 {
- (*z).encodedPaymentTxnFields.Amount = ((*z).encodedPaymentTxnFields.Amount)[:zb0098]
+ } else if (*z).encodedPaymentTxnFields.Amount != nil && cap((*z).encodedPaymentTxnFields.Amount) >= zb0105 {
+ (*z).encodedPaymentTxnFields.Amount = ((*z).encodedPaymentTxnFields.Amount)[:zb0105]
} else {
- (*z).encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0098)
+ (*z).encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0105)
}
- for zb0008 := range (*z).encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedPaymentTxnFields.Amount[zb0008].UnmarshalMsg(bts)
+ for zb0009 := range (*z).encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedPaymentTxnFields.Amount[zb0009].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Amount", zb0008)
+ err = msgp.WrapError(err, "struct-from-array", "Amount", zb0009)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0100 []byte
- var zb0101 int
- zb0101, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0107 []byte
+ var zb0108 int
+ zb0108, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- if zb0101 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0101), uint64(maxBitmaskSize))
+ if zb0108 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0108), uint64(maxBitmaskSize))
return
}
- zb0100, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskAmount))
+ zb0107, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- (*z).encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0100)
+ (*z).encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0107)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0102 int
- zb0102, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0109 int
+ zb0109, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CloseRemainderTo")
return
}
- if zb0102 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0102), uint64(maxAddressBytes))
+ if zb0109 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0109), uint64(maxAddressBytes))
return
}
(*z).encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedPaymentTxnFields.CloseRemainderTo)
@@ -21288,366 +22484,366 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0103 []byte
- var zb0104 int
- zb0104, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0110 []byte
+ var zb0111 int
+ zb0111, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- if zb0104 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0104), uint64(maxBitmaskSize))
+ if zb0111 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0111), uint64(maxBitmaskSize))
return
}
- zb0103, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0110, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- (*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0103)
+ (*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0110)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0105 int
- var zb0106 bool
- zb0105, zb0106, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0112 int
+ var zb0113 bool
+ zb0112, zb0113, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0105 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0105), uint64(maxEncodedTransactionGroups))
+ if zb0112 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0112), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0106 {
+ if zb0113 {
(*z).encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedAssetConfigTxnFields.ConfigAsset) >= zb0105 {
- (*z).encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedAssetConfigTxnFields.ConfigAsset)[:zb0105]
+ } else if (*z).encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedAssetConfigTxnFields.ConfigAsset) >= zb0112 {
+ (*z).encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedAssetConfigTxnFields.ConfigAsset)[:zb0112]
} else {
- (*z).encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0105)
+ (*z).encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0112)
}
- for zb0009 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0009].UnmarshalMsg(bts)
+ for zb0010 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0010].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0009)
+ err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0010)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0107 []byte
- var zb0108 int
- zb0108, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0114 []byte
+ var zb0115 int
+ zb0115, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- if zb0108 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0108), uint64(maxBitmaskSize))
+ if zb0115 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0115), uint64(maxBitmaskSize))
return
}
- zb0107, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0114, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- (*z).encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0107)
+ (*z).encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0114)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0109 int
- var zb0110 bool
- zb0109, zb0110, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0116 int
+ var zb0117 bool
+ zb0116, zb0117, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0109 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0109), uint64(maxEncodedTransactionGroups))
+ if zb0116 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0116), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0110 {
+ if zb0117 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0109 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0109]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0116 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0116]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0109)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0116)
}
- for zb0010 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0010], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0011], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Total", zb0010)
+ err = msgp.WrapError(err, "struct-from-array", "Total", zb0011)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0111 []byte
- var zb0112 int
- zb0112, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0118 []byte
+ var zb0119 int
+ zb0119, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- if zb0112 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0112), uint64(maxBitmaskSize))
+ if zb0119 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0119), uint64(maxBitmaskSize))
return
}
- zb0111, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0118, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0111)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0118)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0113 int
- var zb0114 bool
- zb0113, zb0114, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0120 int
+ var zb0121 bool
+ zb0120, zb0121, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0113 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0113), uint64(maxEncodedTransactionGroups))
+ if zb0120 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0120), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0114 {
+ if zb0121 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0113 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0113]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0120 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0120]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0113)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0120)
}
- for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0011], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0012], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0011)
+ err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0012)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0115 []byte
- var zb0116 int
- zb0116, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0122 []byte
+ var zb0123 int
+ zb0123, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- if zb0116 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0116), uint64(maxBitmaskSize))
+ if zb0123 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0123), uint64(maxBitmaskSize))
return
}
- zb0115, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0122, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0115)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0122)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0117 []byte
- var zb0118 int
- zb0118, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0124 []byte
+ var zb0125 int
+ zb0125, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- if zb0118 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0118), uint64(maxBitmaskSize))
+ if zb0125 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0125), uint64(maxBitmaskSize))
return
}
- zb0117, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0124, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0117)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0124)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0119 int
- var zb0120 bool
- zb0119, zb0120, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0126 int
+ var zb0127 bool
+ zb0126, zb0127, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0119 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0119), uint64(maxEncodedTransactionGroups))
+ if zb0126 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0126), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0120 {
+ if zb0127 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0119 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0119]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0126 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0126]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0119)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0126)
}
- for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0012], bts, err = msgp.ReadStringBytes(bts)
+ for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0013], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0012)
+ err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0013)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0121 []byte
- var zb0122 int
- zb0122, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0128 []byte
+ var zb0129 int
+ zb0129, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- if zb0122 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0122), uint64(maxBitmaskSize))
+ if zb0129 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0129), uint64(maxBitmaskSize))
return
}
- zb0121, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0128, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0121)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0128)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0123 int
- var zb0124 bool
- zb0123, zb0124, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0130 int
+ var zb0131 bool
+ zb0130, zb0131, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0123 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0123), uint64(maxEncodedTransactionGroups))
+ if zb0130 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0130), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0124 {
+ if zb0131 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0123 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0123]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0130 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0130]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0123)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0130)
}
- for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0013], bts, err = msgp.ReadStringBytes(bts)
+ for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0014], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0013)
+ err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0014)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0125 []byte
- var zb0126 int
- zb0126, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0132 []byte
+ var zb0133 int
+ zb0133, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- if zb0126 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0126), uint64(maxBitmaskSize))
+ if zb0133 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0133), uint64(maxBitmaskSize))
return
}
- zb0125, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0132, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0125)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0132)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0127 int
- var zb0128 bool
- zb0127, zb0128, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0134 int
+ var zb0135 bool
+ zb0134, zb0135, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0127 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0127), uint64(maxEncodedTransactionGroups))
+ if zb0134 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0134), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0128 {
+ if zb0135 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0127 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0127]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0134 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0134]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0127)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0134)
}
- for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0014], bts, err = msgp.ReadStringBytes(bts)
+ for zb0015 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0015], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "URL", zb0014)
+ err = msgp.WrapError(err, "struct-from-array", "URL", zb0015)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0129 []byte
- var zb0130 int
- zb0130, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0136 []byte
+ var zb0137 int
+ zb0137, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- if zb0130 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0130), uint64(maxBitmaskSize))
+ if zb0137 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0137), uint64(maxBitmaskSize))
return
}
- zb0129, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0136, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0129)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0136)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0131 int
- zb0131, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0138 int
+ zb0138, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "MetadataHash")
return
}
- if zb0131 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0131), uint64(maxAddressBytes))
+ if zb0138 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0138), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -21656,38 +22852,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0132 []byte
- var zb0133 int
- zb0133, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0139 []byte
+ var zb0140 int
+ zb0140, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- if zb0133 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0133), uint64(maxBitmaskSize))
+ if zb0140 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0140), uint64(maxBitmaskSize))
return
}
- zb0132, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0139, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0132)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0139)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0134 int
- zb0134, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0141 int
+ zb0141, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Manager")
return
}
- if zb0134 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0134), uint64(maxAddressBytes))
+ if zb0141 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0141), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -21696,38 +22892,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0135 []byte
- var zb0136 int
- zb0136, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0142 []byte
+ var zb0143 int
+ zb0143, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- if zb0136 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0136), uint64(maxBitmaskSize))
+ if zb0143 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0143), uint64(maxBitmaskSize))
return
}
- zb0135, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0142, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0135)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0142)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0137 int
- zb0137, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0144 int
+ zb0144, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reserve")
return
}
- if zb0137 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0137), uint64(maxAddressBytes))
+ if zb0144 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0144), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -21736,38 +22932,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0138 []byte
- var zb0139 int
- zb0139, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0145 []byte
+ var zb0146 int
+ zb0146, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- if zb0139 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0139), uint64(maxBitmaskSize))
+ if zb0146 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0146), uint64(maxBitmaskSize))
return
}
- zb0138, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0145, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0138)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0145)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0140 int
- zb0140, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0147 int
+ zb0147, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Freeze")
return
}
- if zb0140 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0140), uint64(maxAddressBytes))
+ if zb0147 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0147), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -21776,38 +22972,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0141 []byte
- var zb0142 int
- zb0142, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0148 []byte
+ var zb0149 int
+ zb0149, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- if zb0142 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0142), uint64(maxBitmaskSize))
+ if zb0149 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0149), uint64(maxBitmaskSize))
return
}
- zb0141, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0148, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0141)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0148)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0143 int
- zb0143, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0150 int
+ zb0150, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Clawback")
return
}
- if zb0143 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0143), uint64(maxAddressBytes))
+ if zb0150 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0150), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -21816,140 +23012,140 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0144 []byte
- var zb0145 int
- zb0145, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0151 []byte
+ var zb0152 int
+ zb0152, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- if zb0145 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0145), uint64(maxBitmaskSize))
+ if zb0152 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0152), uint64(maxBitmaskSize))
return
}
- zb0144, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0151, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0144)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0151)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0146 int
- var zb0147 bool
- zb0146, zb0147, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0153 int
+ var zb0154 bool
+ zb0153, zb0154, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0146 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0146), uint64(maxEncodedTransactionGroups))
+ if zb0153 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0153), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0147 {
+ if zb0154 {
(*z).encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedAssetTransferTxnFields.XferAsset) >= zb0146 {
- (*z).encodedAssetTransferTxnFields.XferAsset = ((*z).encodedAssetTransferTxnFields.XferAsset)[:zb0146]
+ } else if (*z).encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedAssetTransferTxnFields.XferAsset) >= zb0153 {
+ (*z).encodedAssetTransferTxnFields.XferAsset = ((*z).encodedAssetTransferTxnFields.XferAsset)[:zb0153]
} else {
- (*z).encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0146)
+ (*z).encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0153)
}
- for zb0015 := range (*z).encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedAssetTransferTxnFields.XferAsset[zb0015].UnmarshalMsg(bts)
+ for zb0016 := range (*z).encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedAssetTransferTxnFields.XferAsset[zb0016].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0015)
+ err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0016)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0148 []byte
- var zb0149 int
- zb0149, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0155 []byte
+ var zb0156 int
+ zb0156, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- if zb0149 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0149), uint64(maxBitmaskSize))
+ if zb0156 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0156), uint64(maxBitmaskSize))
return
}
- zb0148, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0155, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0148)
+ (*z).encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0155)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0150 int
- var zb0151 bool
- zb0150, zb0151, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0157 int
+ var zb0158 bool
+ zb0157, zb0158, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0150 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0150), uint64(maxEncodedTransactionGroups))
+ if zb0157 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0157), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0151 {
+ if zb0158 {
(*z).encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedAssetTransferTxnFields.AssetAmount) >= zb0150 {
- (*z).encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedAssetTransferTxnFields.AssetAmount)[:zb0150]
+ } else if (*z).encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedAssetTransferTxnFields.AssetAmount) >= zb0157 {
+ (*z).encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedAssetTransferTxnFields.AssetAmount)[:zb0157]
} else {
- (*z).encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0150)
+ (*z).encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0157)
}
- for zb0016 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedAssetTransferTxnFields.AssetAmount[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0017 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedAssetTransferTxnFields.AssetAmount[zb0017], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0016)
+ err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0017)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0152 []byte
- var zb0153 int
- zb0153, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0159 []byte
+ var zb0160 int
+ zb0160, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- if zb0153 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0153), uint64(maxBitmaskSize))
+ if zb0160 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0160), uint64(maxBitmaskSize))
return
}
- zb0152, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0159, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0152)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0159)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0154 int
- zb0154, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0161 int
+ zb0161, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetSender")
return
}
- if zb0154 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0154), uint64(maxAddressBytes))
+ if zb0161 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0161), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetSender)
@@ -21958,38 +23154,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0155 []byte
- var zb0156 int
- zb0156, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0162 []byte
+ var zb0163 int
+ zb0163, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- if zb0156 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0156), uint64(maxBitmaskSize))
+ if zb0163 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0163), uint64(maxBitmaskSize))
return
}
- zb0155, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0162, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0155)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0162)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0157 int
- zb0157, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0164 int
+ zb0164, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetReceiver")
return
}
- if zb0157 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0157), uint64(maxAddressBytes))
+ if zb0164 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0164), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetReceiver)
@@ -21998,38 +23194,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0158 []byte
- var zb0159 int
- zb0159, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0165 []byte
+ var zb0166 int
+ zb0166, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- if zb0159 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0159), uint64(maxBitmaskSize))
+ if zb0166 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0166), uint64(maxBitmaskSize))
return
}
- zb0158, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0165, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0158)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0165)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0160 int
- zb0160, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0167 int
+ zb0167, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetCloseTo")
return
}
- if zb0160 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0160), uint64(maxAddressBytes))
+ if zb0167 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0167), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetCloseTo)
@@ -22038,38 +23234,38 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0161 []byte
- var zb0162 int
- zb0162, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0168 []byte
+ var zb0169 int
+ zb0169, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- if zb0162 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0162), uint64(maxBitmaskSize))
+ if zb0169 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0169), uint64(maxBitmaskSize))
return
}
- zb0161, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0168, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0161)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0168)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0163 int
- zb0163, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0170 int
+ zb0170, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAccount")
return
}
- if zb0163 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0163), uint64(maxAddressBytes))
+ if zb0170 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0170), uint64(maxAddressBytes))
return
}
(*z).encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetFreezeTxnFields.FreezeAccount)
@@ -22078,162 +23274,162 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0164 []byte
- var zb0165 int
- zb0165, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0171 []byte
+ var zb0172 int
+ zb0172, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- if zb0165 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0165), uint64(maxBitmaskSize))
+ if zb0172 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0172), uint64(maxBitmaskSize))
return
}
- zb0164, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0171, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0164)
+ (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0171)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0166 int
- var zb0167 bool
- zb0166, zb0167, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0173 int
+ var zb0174 bool
+ zb0173, zb0174, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0166 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0166), uint64(maxEncodedTransactionGroups))
+ if zb0173 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0173), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0167 {
+ if zb0174 {
(*z).encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedAssetFreezeTxnFields.FreezeAsset) >= zb0166 {
- (*z).encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedAssetFreezeTxnFields.FreezeAsset)[:zb0166]
+ } else if (*z).encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedAssetFreezeTxnFields.FreezeAsset) >= zb0173 {
+ (*z).encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedAssetFreezeTxnFields.FreezeAsset)[:zb0173]
} else {
- (*z).encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0166)
+ (*z).encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0173)
}
- for zb0017 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0017].UnmarshalMsg(bts)
+ for zb0018 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0018].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0017)
+ err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0018)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0168 []byte
- var zb0169 int
- zb0169, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0175 []byte
+ var zb0176 int
+ zb0176, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- if zb0169 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0169), uint64(maxBitmaskSize))
+ if zb0176 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0176), uint64(maxBitmaskSize))
return
}
- zb0168, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0175, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0168)
+ (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0175)
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0170 []byte
- var zb0171 int
- zb0171, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0177 []byte
+ var zb0178 int
+ zb0178, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- if zb0171 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0171), uint64(maxBitmaskSize))
+ if zb0178 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0178), uint64(maxBitmaskSize))
return
}
- zb0170, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0177, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0170)
+ (*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0177)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0172 int
- var zb0173 bool
- zb0172, zb0173, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0179 int
+ var zb0180 bool
+ zb0179, zb0180, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0172 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0172), uint64(maxEncodedTransactionGroups))
+ if zb0179 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0179), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0173 {
+ if zb0180 {
(*z).encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationID) >= zb0172 {
- (*z).encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedApplicationCallTxnFields.ApplicationID)[:zb0172]
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationID) >= zb0179 {
+ (*z).encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedApplicationCallTxnFields.ApplicationID)[:zb0179]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0172)
+ (*z).encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0179)
}
- for zb0018 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0018].UnmarshalMsg(bts)
+ for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0019].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0018)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0019)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0174 []byte
- var zb0175 int
- zb0175, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0181 []byte
+ var zb0182 int
+ zb0182, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- if zb0175 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0175), uint64(maxBitmaskSize))
+ if zb0182 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0182), uint64(maxBitmaskSize))
return
}
- zb0174, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0181, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0174)
+ (*z).encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0181)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0176 int
- zb0176, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0183 int
+ zb0183, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "OnCompletion")
return
}
- if zb0176 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0176), uint64(maxEncodedTransactionGroups))
+ if zb0183 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0183), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.OnCompletion)
@@ -22242,1119 +23438,1232 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0177 []byte
- var zb0178 int
- zb0178, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0184 []byte
+ var zb0185 int
+ zb0185, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- if zb0178 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0178), uint64(maxBitmaskSize))
+ if zb0185 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0185), uint64(maxBitmaskSize))
return
}
- zb0177, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0184, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0177)
+ (*z).encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0184)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0179 int
- var zb0180 bool
- zb0179, zb0180, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0186 int
+ var zb0187 bool
+ zb0186, zb0187, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0179 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0179), uint64(maxEncodedTransactionGroups))
+ if zb0186 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0186), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0180 {
+ if zb0187 {
(*z).encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs) >= zb0179 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedApplicationCallTxnFields.ApplicationArgs)[:zb0179]
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs) >= zb0186 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedApplicationCallTxnFields.ApplicationArgs)[:zb0186]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0179)
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0186)
}
- for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0181 int
- var zb0182 bool
- zb0181, zb0182, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0188 int
+ var zb0189 bool
+ zb0188, zb0189, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0019)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0020)
return
}
- if zb0181 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0181), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0019)
+ if zb0188 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0188), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0020)
return
}
- if zb0182 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019]) >= zb0181 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = ((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019])[:zb0181]
+ if zb0189 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020]) >= zb0188 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = ((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020])[:zb0188]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = make(applicationArgs, zb0181)
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = make(applicationArgs, zb0188)
}
- for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020])
+ for zb0021 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021])
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0019, zb0020)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0020, zb0021)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0183 []byte
- var zb0184 int
- zb0184, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0190 []byte
+ var zb0191 int
+ zb0191, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- if zb0184 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0184), uint64(maxBitmaskSize))
+ if zb0191 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0191), uint64(maxBitmaskSize))
return
}
- zb0183, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0190, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0183)
+ (*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0190)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0185 int
- var zb0186 bool
- zb0185, zb0186, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0192 int
+ var zb0193 bool
+ zb0192, zb0193, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0185 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0185), uint64(maxEncodedTransactionGroups))
+ if zb0192 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0192), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0186 {
+ if zb0193 {
(*z).encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedApplicationCallTxnFields.Accounts) >= zb0185 {
- (*z).encodedApplicationCallTxnFields.Accounts = ((*z).encodedApplicationCallTxnFields.Accounts)[:zb0185]
+ } else if (*z).encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedApplicationCallTxnFields.Accounts) >= zb0192 {
+ (*z).encodedApplicationCallTxnFields.Accounts = ((*z).encodedApplicationCallTxnFields.Accounts)[:zb0192]
} else {
- (*z).encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0185)
+ (*z).encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0192)
}
- for zb0021 := range (*z).encodedApplicationCallTxnFields.Accounts {
- var zb0187 int
- var zb0188 bool
- zb0187, zb0188, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts {
+ var zb0194 int
+ var zb0195 bool
+ zb0194, zb0195, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0021)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0022)
return
}
- if zb0187 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0187), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0021)
+ if zb0194 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0194), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0022)
return
}
- if zb0188 {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = nil
- } else if (*z).encodedApplicationCallTxnFields.Accounts[zb0021] != nil && cap((*z).encodedApplicationCallTxnFields.Accounts[zb0021]) >= zb0187 {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = ((*z).encodedApplicationCallTxnFields.Accounts[zb0021])[:zb0187]
+ if zb0195 {
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = nil
+ } else if (*z).encodedApplicationCallTxnFields.Accounts[zb0022] != nil && cap((*z).encodedApplicationCallTxnFields.Accounts[zb0022]) >= zb0194 {
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = ((*z).encodedApplicationCallTxnFields.Accounts[zb0022])[:zb0194]
} else {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = make(addresses, zb0187)
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = make(addresses, zb0194)
}
- for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0021] {
- bts, err = (*z).encodedApplicationCallTxnFields.Accounts[zb0021][zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0022] {
+ bts, err = (*z).encodedApplicationCallTxnFields.Accounts[zb0022][zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0021, zb0022)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0022, zb0023)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0189 []byte
- var zb0190 int
- zb0190, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0196 []byte
+ var zb0197 int
+ zb0197, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- if zb0190 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0190), uint64(maxBitmaskSize))
+ if zb0197 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0197), uint64(maxBitmaskSize))
return
}
- zb0189, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0196, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0189)
+ (*z).encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0196)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0191 int
- var zb0192 bool
- zb0191, zb0192, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0198 int
+ var zb0199 bool
+ zb0198, zb0199, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0191 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0191), uint64(maxEncodedTransactionGroups))
+ if zb0198 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0198), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0192 {
+ if zb0199 {
(*z).encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps) >= zb0191 {
- (*z).encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedApplicationCallTxnFields.ForeignApps)[:zb0191]
+ } else if (*z).encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps) >= zb0198 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedApplicationCallTxnFields.ForeignApps)[:zb0198]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0191)
+ (*z).encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0198)
}
- for zb0023 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
- var zb0193 int
- var zb0194 bool
- zb0193, zb0194, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
+ var zb0200 int
+ var zb0201 bool
+ zb0200, zb0201, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0023)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0024)
return
}
- if zb0193 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0193), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0023)
+ if zb0200 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0200), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0024)
return
}
- if zb0194 {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps[zb0023]) >= zb0193 {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = ((*z).encodedApplicationCallTxnFields.ForeignApps[zb0023])[:zb0193]
+ if zb0201 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps[zb0024]) >= zb0200 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = ((*z).encodedApplicationCallTxnFields.ForeignApps[zb0024])[:zb0200]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = make(appIndices, zb0193)
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = make(appIndices, zb0200)
}
- for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] {
- bts, err = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023][zb0024].UnmarshalMsg(bts)
+ for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] {
+ bts, err = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024][zb0025].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0023, zb0024)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0024, zb0025)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0195 []byte
- var zb0196 int
- zb0196, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0202 []byte
+ var zb0203 int
+ zb0203, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- if zb0196 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0196), uint64(maxBitmaskSize))
+ if zb0203 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0203), uint64(maxBitmaskSize))
return
}
- zb0195, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0202, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0195)
+ (*z).encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0202)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0197 int
- var zb0198 bool
- zb0197, zb0198, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0204 int
+ var zb0205 bool
+ zb0204, zb0205, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0197 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0197), uint64(maxEncodedTransactionGroups))
+ if zb0204 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0204), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0198 {
+ if zb0205 {
(*z).encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets) >= zb0197 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedApplicationCallTxnFields.ForeignAssets)[:zb0197]
+ } else if (*z).encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets) >= zb0204 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedApplicationCallTxnFields.ForeignAssets)[:zb0204]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0197)
+ (*z).encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0204)
}
- for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
- var zb0199 int
- var zb0200 bool
- zb0199, zb0200, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0206 int
+ var zb0207 bool
+ zb0206, zb0207, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0025)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0026)
return
}
- if zb0199 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0199), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0025)
+ if zb0206 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0206), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0026)
return
}
- if zb0200 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025]) >= zb0199 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = ((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025])[:zb0199]
+ if zb0207 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026]) >= zb0206 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = ((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026])[:zb0206]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = make(assetIndices, zb0199)
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = make(assetIndices, zb0206)
}
- for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] {
- bts, err = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025][zb0026].UnmarshalMsg(bts)
+ for zb0027 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] {
+ bts, err = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026][zb0027].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0025, zb0026)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0026, zb0027)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0201 []byte
- var zb0202 int
- zb0202, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0208 []byte
+ var zb0209 int
+ zb0209, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- if zb0202 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0202), uint64(maxBitmaskSize))
+ if zb0209 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0209), uint64(maxBitmaskSize))
return
}
- zb0201, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0208, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0201)
+ (*z).encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0208)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0203 int
- var zb0204 bool
- zb0203, zb0204, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0210 int
+ var zb0211 bool
+ zb0210, zb0211, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0203 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0203), uint64(maxEncodedTransactionGroups))
+ if zb0210 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0210), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0204 {
+ if zb0211 {
(*z).encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumUint) >= zb0203 {
- (*z).encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedApplicationCallTxnFields.LocalNumUint)[:zb0203]
+ } else if (*z).encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumUint) >= zb0210 {
+ (*z).encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedApplicationCallTxnFields.LocalNumUint)[:zb0210]
} else {
- (*z).encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0203)
+ (*z).encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0210)
}
- for zb0027 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0027], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0028], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0027)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0028)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0205 []byte
- var zb0206 int
- zb0206, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0212 []byte
+ var zb0213 int
+ zb0213, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- if zb0206 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0206), uint64(maxBitmaskSize))
+ if zb0213 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0213), uint64(maxBitmaskSize))
return
}
- zb0205, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0212, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0205)
+ (*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0212)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0207 int
- var zb0208 bool
- zb0207, zb0208, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0214 int
+ var zb0215 bool
+ zb0214, zb0215, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0207 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0207), uint64(maxEncodedTransactionGroups))
+ if zb0214 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0214), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0208 {
+ if zb0215 {
(*z).encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0207 {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0207]
+ } else if (*z).encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0214 {
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0214]
} else {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0207)
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0214)
}
- for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0028], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0029 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0029], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0028)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0029)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0209 []byte
- var zb0210 int
- zb0210, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0216 []byte
+ var zb0217 int
+ zb0217, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- if zb0210 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0210), uint64(maxBitmaskSize))
+ if zb0217 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0217), uint64(maxBitmaskSize))
return
}
- zb0209, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0216, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0209)
+ (*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0216)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0211 int
- var zb0212 bool
- zb0211, zb0212, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0218 int
+ var zb0219 bool
+ zb0218, zb0219, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0211 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0211), uint64(maxEncodedTransactionGroups))
+ if zb0218 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0218), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0212 {
+ if zb0219 {
(*z).encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumUint) >= zb0211 {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedApplicationCallTxnFields.GlobalNumUint)[:zb0211]
+ } else if (*z).encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumUint) >= zb0218 {
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedApplicationCallTxnFields.GlobalNumUint)[:zb0218]
} else {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0211)
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0218)
}
- for zb0029 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0029], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0030], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0029)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0030)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0213 []byte
- var zb0214 int
- zb0214, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0220 []byte
+ var zb0221 int
+ zb0221, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- if zb0214 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0214), uint64(maxBitmaskSize))
+ if zb0221 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0221), uint64(maxBitmaskSize))
return
}
- zb0213, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0220, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0213)
+ (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0220)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0215 int
- var zb0216 bool
- zb0215, zb0216, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0222 int
+ var zb0223 bool
+ zb0222, zb0223, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0215 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0215), uint64(maxEncodedTransactionGroups))
+ if zb0222 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0222), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0216 {
+ if zb0223 {
(*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0215 {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0215]
+ } else if (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0222 {
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0222]
} else {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0215)
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0222)
}
- for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0030], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0031 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0031], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0030)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0031)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0217 []byte
- var zb0218 int
- zb0218, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0224 []byte
+ var zb0225 int
+ zb0225, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- if zb0218 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0218), uint64(maxBitmaskSize))
+ if zb0225 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0225), uint64(maxBitmaskSize))
return
}
- zb0217, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0224, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0217)
+ (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0224)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0219 int
- var zb0220 bool
- zb0219, zb0220, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0226 int
+ var zb0227 bool
+ zb0226, zb0227, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0219 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0219), uint64(maxEncodedTransactionGroups))
+ if zb0226 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0226), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0220 {
+ if zb0227 {
(*z).encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedApplicationCallTxnFields.ApprovalProgram) >= zb0219 {
- (*z).encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedApplicationCallTxnFields.ApprovalProgram)[:zb0219]
+ } else if (*z).encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedApplicationCallTxnFields.ApprovalProgram) >= zb0226 {
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedApplicationCallTxnFields.ApprovalProgram)[:zb0226]
} else {
- (*z).encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0219)
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0226)
}
- for zb0031 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0032 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0221 []byte
- var zb0222 int
- zb0222, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0228 []byte
+ var zb0229 int
+ zb0229, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0031)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0032)
return
}
- if zb0222 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0222), uint64(config.MaxAvailableAppProgramLen))
+ if zb0229 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0229), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0221, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031]))
+ zb0228, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0031)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0032)
return
}
- (*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031] = program(zb0221)
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032] = program(zb0228)
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0223 []byte
- var zb0224 int
- zb0224, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0230 []byte
+ var zb0231 int
+ zb0231, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- if zb0224 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0224), uint64(maxBitmaskSize))
+ if zb0231 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0231), uint64(maxBitmaskSize))
return
}
- zb0223, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0230, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0223)
+ (*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0230)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0225 int
- var zb0226 bool
- zb0225, zb0226, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0232 int
+ var zb0233 bool
+ zb0232, zb0233, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0225 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0225), uint64(maxEncodedTransactionGroups))
+ if zb0232 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0232), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0226 {
+ if zb0233 {
(*z).encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedApplicationCallTxnFields.ClearStateProgram) >= zb0225 {
- (*z).encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedApplicationCallTxnFields.ClearStateProgram)[:zb0225]
+ } else if (*z).encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedApplicationCallTxnFields.ClearStateProgram) >= zb0232 {
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedApplicationCallTxnFields.ClearStateProgram)[:zb0232]
} else {
- (*z).encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0225)
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0232)
}
- for zb0032 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0033 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0227 []byte
- var zb0228 int
- zb0228, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0234 []byte
+ var zb0235 int
+ zb0235, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0032)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0033)
return
}
- if zb0228 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0228), uint64(config.MaxAvailableAppProgramLen))
+ if zb0235 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0235), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0227, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032]))
+ zb0234, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0032)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0033)
return
}
- (*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032] = program(zb0227)
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033] = program(zb0234)
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0229 []byte
- var zb0230 int
- zb0230, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0236 []byte
+ var zb0237 int
+ zb0237, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- if zb0230 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0230), uint64(maxBitmaskSize))
+ if zb0237 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0237), uint64(maxBitmaskSize))
return
}
- zb0229, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0236, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0229)
+ (*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0236)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0231 int
- var zb0232 bool
- zb0231, zb0232, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0238 int
+ var zb0239 bool
+ zb0238, zb0239, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0231 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0231), uint64(maxEncodedTransactionGroups))
+ if zb0238 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0238), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0232 {
+ if zb0239 {
(*z).encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0231 {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0231]
+ } else if (*z).encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0238 {
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0238]
} else {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0231)
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0238)
}
- for zb0033 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0033], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0034 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0034], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0033)
+ err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0034)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0233 []byte
- var zb0234 int
- zb0234, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0240 []byte
+ var zb0241 int
+ zb0241, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- if zb0234 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0234), uint64(maxBitmaskSize))
+ if zb0241 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0241), uint64(maxBitmaskSize))
return
}
- zb0233, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0240, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0233)
+ (*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0240)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0235 int
- var zb0236 bool
- zb0235, zb0236, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0242 int
+ var zb0243 bool
+ zb0242, zb0243, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0235 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0235), uint64(maxEncodedTransactionGroups))
+ if zb0242 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0242), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0236 {
+ if zb0243 {
(*z).encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedCompactCertTxnFields.CertRound) >= zb0235 {
- (*z).encodedCompactCertTxnFields.CertRound = ((*z).encodedCompactCertTxnFields.CertRound)[:zb0235]
+ } else if (*z).encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedCompactCertTxnFields.CertRound) >= zb0242 {
+ (*z).encodedCompactCertTxnFields.CertRound = ((*z).encodedCompactCertTxnFields.CertRound)[:zb0242]
} else {
- (*z).encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0235)
+ (*z).encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0242)
}
- for zb0034 := range (*z).encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedCompactCertTxnFields.CertRound[zb0034].UnmarshalMsg(bts)
+ for zb0035 := range (*z).encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedCompactCertTxnFields.CertRound[zb0035].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0034)
+ err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0035)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0237 []byte
- var zb0238 int
- zb0238, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0244 []byte
+ var zb0245 int
+ zb0245, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- if zb0238 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0238), uint64(maxBitmaskSize))
+ if zb0245 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0245), uint64(maxBitmaskSize))
return
}
- zb0237, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0244, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- (*z).encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0237)
+ (*z).encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0244)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0239 int
- var zb0240 bool
- zb0239, zb0240, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0246 int
+ var zb0247 bool
+ zb0246, zb0247, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0239 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0239), uint64(maxEncodedTransactionGroups))
+ if zb0246 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0246), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0240 {
+ if zb0247 {
(*z).encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedCompactCertTxnFields.CertType) >= zb0239 {
- (*z).encodedCompactCertTxnFields.CertType = ((*z).encodedCompactCertTxnFields.CertType)[:zb0239]
+ } else if (*z).encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedCompactCertTxnFields.CertType) >= zb0246 {
+ (*z).encodedCompactCertTxnFields.CertType = ((*z).encodedCompactCertTxnFields.CertType)[:zb0246]
} else {
- (*z).encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0239)
+ (*z).encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0246)
}
- for zb0035 := range (*z).encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedCompactCertTxnFields.CertType[zb0035].UnmarshalMsg(bts)
+ for zb0036 := range (*z).encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedCompactCertTxnFields.CertType[zb0036].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertType", zb0035)
+ err = msgp.WrapError(err, "struct-from-array", "CertType", zb0036)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0241 []byte
- var zb0242 int
- zb0242, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0248 []byte
+ var zb0249 int
+ zb0249, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- if zb0242 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0242), uint64(maxBitmaskSize))
+ if zb0249 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0249), uint64(maxBitmaskSize))
return
}
- zb0241, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertType))
+ zb0248, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- (*z).encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0241)
+ (*z).encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0248)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0243 int
- zb0243, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0250 int
+ var zb0251 bool
+ zb0250, zb0251, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
- if zb0243 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0243), uint64(maxAddressBytes))
- return
- }
- (*z).encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0250 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0250), uint64(maxAddressBytes))
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
+ if zb0251 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0250 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0250]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0250)
+ }
+ for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigCommit[zb0037].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigCommit", zb0037)
+ return
+ }
+ }
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0244 []byte
- var zb0245 int
- zb0245, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0252 []byte
+ var zb0253 int
+ zb0253, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- if zb0245 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0245), uint64(maxBitmaskSize))
+ if zb0253 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0253), uint64(maxBitmaskSize))
return
}
- zb0244, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0252, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0244)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0252)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0246 int
- var zb0247 bool
- zb0246, zb0247, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0254 int
+ var zb0255 bool
+ zb0254, zb0255, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0246 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0246), uint64(maxEncodedTransactionGroups))
+ if zb0254 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0254), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0247 {
+ if zb0255 {
(*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0246 {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0246]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0254 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0254]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0246)
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0254)
}
- for zb0036 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0038], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0036)
+ err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0038)
return
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0248 []byte
- var zb0249 int
- zb0249, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0256 []byte
+ var zb0257 int
+ zb0257, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- if zb0249 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0249), uint64(maxBitmaskSize))
+ if zb0257 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0257), uint64(maxBitmaskSize))
return
}
- zb0248, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0256, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0248)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0256)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0250 int
- var zb0251 bool
- zb0250, zb0251, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0258 int
+ var zb0259 bool
+ zb0258, zb0259, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0250 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0250), uint64(maxEncodedTransactionGroups))
+ if zb0258 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0258), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0251 {
+ if zb0259 {
(*z).encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0250 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0250]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0258 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0258]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0250)
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0258)
}
- for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0252 int
- var zb0253 bool
- zb0252, zb0253, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0260 int
+ var zb0261 bool
+ zb0260, zb0261, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0037)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0039)
return
}
- if zb0252 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0252), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0037)
+ if zb0260 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0260), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0039)
return
}
- if zb0253 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037]) >= zb0252 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037])[:zb0252]
+ if zb0261 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039]) >= zb0260 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039])[:zb0260]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = make(certProofs, zb0252)
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = make(certProofs, zb0260)
}
- for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] {
- bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037][zb0038].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039][zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0037, zb0038)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0039, zb0040)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0254 []byte
- var zb0255 int
- zb0255, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0262 []byte
+ var zb0263 int
+ zb0263, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- if zb0255 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0255), uint64(maxBitmaskSize))
+ if zb0263 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0263), uint64(maxBitmaskSize))
return
}
- zb0254, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0262, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0254)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0262)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0256 int
- var zb0257 bool
- zb0256, zb0257, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0264 int
+ var zb0265 bool
+ zb0264, zb0265, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0264 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0264), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0265 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0264 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0264]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0264)
+ }
+ for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes", zb0041)
+ return
+ }
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ {
+ var zb0266 []byte
+ var zb0267 int
+ zb0267, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ if zb0267 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0267), uint64(maxBitmaskSize))
+ return
+ }
+ zb0266, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0266)
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ var zb0268 int
+ var zb0269 bool
+ zb0268, zb0269, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0256 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0256), uint64(maxEncodedTransactionGroups))
+ if zb0268 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0268), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0257 {
+ if zb0269 {
(*z).encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0256 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0256]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0268 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0268]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0256)
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0268)
}
- for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0258 int
- var zb0259 bool
- zb0258, zb0259, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0042 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0270 int
+ var zb0271 bool
+ zb0270, zb0271, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0039)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0042)
return
}
- if zb0258 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0258), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0039)
+ if zb0270 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0270), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0042)
return
}
- if zb0259 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039]) >= zb0258 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039])[:zb0258]
+ if zb0271 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042]) >= zb0270 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042])[:zb0270]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = make(certProofs, zb0258)
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = make(certProofs, zb0270)
}
- for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] {
- bts, err = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039][zb0040].UnmarshalMsg(bts)
+ for zb0043 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042][zb0043].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0039, zb0040)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0042, zb0043)
return
}
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0260 []byte
- var zb0261 int
- zb0261, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0272 []byte
+ var zb0273 int
+ zb0273, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- if zb0261 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0261), uint64(maxBitmaskSize))
+ if zb0273 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0273), uint64(maxBitmaskSize))
return
}
- zb0260, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0272, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0260)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0272)
}
}
- if zb0044 > 0 {
- zb0044--
- var zb0262 int
- var zb0263 bool
- zb0262, zb0263, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0048 > 0 {
+ zb0048--
+ var zb0274 int
+ var zb0275 bool
+ zb0274, zb0275, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0274 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0274), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0275 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0274 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0274]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0274)
+ }
+ for zb0044 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0044], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes", zb0044)
+ return
+ }
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ {
+ var zb0276 []byte
+ var zb0277 int
+ zb0277, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ if zb0277 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0277), uint64(maxBitmaskSize))
+ return
+ }
+ zb0276, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0276)
+ }
+ }
+ if zb0048 > 0 {
+ zb0048--
+ var zb0278 int
+ var zb0279 bool
+ zb0278, zb0279, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0262 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0262), uint64(maxEncodedTransactionGroups))
+ if zb0278 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0278), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0263 {
+ if zb0279 {
(*z).encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0262 {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0262]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0278 {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0278]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0262)
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0278)
}
- for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0264 int
- var zb0265 bool
- zb0264, zb0265, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0045 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0280 int
+ var zb0281 bool
+ zb0280, zb0281, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0041)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0045)
return
}
- if zb0264 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0264), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0041)
+ if zb0280 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0280), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0045)
return
}
- if zb0265 {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] == nil {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] = make(revealMap, zb0264)
+ if zb0281 {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] == nil {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] = make(revealMap, zb0280)
}
- for zb0264 > 0 {
- var zb0042 uint64
- var zb0043 compactcert.Reveal
- zb0264--
- zb0042, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0280 > 0 {
+ var zb0046 uint64
+ var zb0047 compactcert.Reveal
+ zb0280--
+ zb0046, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0041)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0045)
return
}
- bts, err = zb0043.UnmarshalMsg(bts)
+ bts, err = zb0047.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0041, zb0042)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0045, zb0046)
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041][zb0042] = zb0043
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045][zb0046] = zb0047
}
}
}
- if zb0044 > 0 {
- zb0044--
+ if zb0048 > 0 {
+ zb0048--
{
- var zb0266 []byte
- var zb0267 int
- zb0267, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0282 []byte
+ var zb0283 int
+ zb0283, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- if zb0267 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0267), uint64(maxBitmaskSize))
+ if zb0283 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0283), uint64(maxBitmaskSize))
return
}
- zb0266, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0282, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0266)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0282)
}
}
- if zb0044 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0044)
+ if zb0048 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0048)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -23365,11 +24674,11 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err)
return
}
- if zb0045 {
+ if zb0049 {
(*z) = encodedTxns{}
}
- for zb0044 > 0 {
- zb0044--
+ for zb0048 > 0 {
+ zb0048--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -23377,14 +24686,14 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
switch string(field) {
case "type":
- var zb0268 int
- zb0268, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0284 int
+ zb0284, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "TxType")
return
}
- if zb0268 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0268), uint64(maxEncodedTransactionGroups))
+ if zb0284 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0284), uint64(maxEncodedTransactionGroups))
return
}
(*z).TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).TxType)
@@ -23394,23 +24703,23 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "typebm":
{
- var zb0269 []byte
- var zb0270 int
- zb0270, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0285 []byte
+ var zb0286 int
+ zb0286, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- if zb0270 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0270), uint64(maxBitmaskSize))
+ if zb0286 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0286), uint64(maxBitmaskSize))
return
}
- zb0269, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskTxType))
+ zb0285, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- (*z).BitmaskTxType = bitmask(zb0269)
+ (*z).BitmaskTxType = bitmask(zb0285)
}
case "typeo":
(*z).TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
@@ -23419,14 +24728,14 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "snd":
- var zb0271 int
- zb0271, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0287 int
+ zb0287, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Sender")
return
}
- if zb0271 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0271), uint64(maxAddressBytes))
+ if zb0287 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0287), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Sender)
@@ -23436,43 +24745,43 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sndbm":
{
- var zb0272 []byte
- var zb0273 int
- zb0273, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0288 []byte
+ var zb0289 int
+ zb0289, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- if zb0273 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0273), uint64(maxBitmaskSize))
+ if zb0289 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0289), uint64(maxBitmaskSize))
return
}
- zb0272, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskSender))
+ zb0288, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- (*z).encodedTxnHeaders.BitmaskSender = bitmask(zb0272)
+ (*z).encodedTxnHeaders.BitmaskSender = bitmask(zb0288)
}
case "fee":
- var zb0274 int
- var zb0275 bool
- zb0274, zb0275, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0290 int
+ var zb0291 bool
+ zb0290, zb0291, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Fee")
return
}
- if zb0274 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0274), uint64(maxEncodedTransactionGroups))
+ if zb0290 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0290), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Fee")
return
}
- if zb0275 {
+ if zb0291 {
(*z).encodedTxnHeaders.Fee = nil
- } else if (*z).encodedTxnHeaders.Fee != nil && cap((*z).encodedTxnHeaders.Fee) >= zb0274 {
- (*z).encodedTxnHeaders.Fee = ((*z).encodedTxnHeaders.Fee)[:zb0274]
+ } else if (*z).encodedTxnHeaders.Fee != nil && cap((*z).encodedTxnHeaders.Fee) >= zb0290 {
+ (*z).encodedTxnHeaders.Fee = ((*z).encodedTxnHeaders.Fee)[:zb0290]
} else {
- (*z).encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0274)
+ (*z).encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0290)
}
for zb0001 := range (*z).encodedTxnHeaders.Fee {
bts, err = (*z).encodedTxnHeaders.Fee[zb0001].UnmarshalMsg(bts)
@@ -23483,43 +24792,43 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "feebm":
{
- var zb0276 []byte
- var zb0277 int
- zb0277, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0292 []byte
+ var zb0293 int
+ zb0293, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- if zb0277 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0277), uint64(maxBitmaskSize))
+ if zb0293 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0293), uint64(maxBitmaskSize))
return
}
- zb0276, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFee))
+ zb0292, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- (*z).encodedTxnHeaders.BitmaskFee = bitmask(zb0276)
+ (*z).encodedTxnHeaders.BitmaskFee = bitmask(zb0292)
}
case "fv":
- var zb0278 int
- var zb0279 bool
- zb0278, zb0279, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0294 int
+ var zb0295 bool
+ zb0294, zb0295, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0278 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0278), uint64(maxEncodedTransactionGroups))
+ if zb0294 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0294), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0279 {
+ if zb0295 {
(*z).encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxnHeaders.FirstValid) >= zb0278 {
- (*z).encodedTxnHeaders.FirstValid = ((*z).encodedTxnHeaders.FirstValid)[:zb0278]
+ } else if (*z).encodedTxnHeaders.FirstValid != nil && cap((*z).encodedTxnHeaders.FirstValid) >= zb0294 {
+ (*z).encodedTxnHeaders.FirstValid = ((*z).encodedTxnHeaders.FirstValid)[:zb0294]
} else {
- (*z).encodedTxnHeaders.FirstValid = make([]basics.Round, zb0278)
+ (*z).encodedTxnHeaders.FirstValid = make([]basics.Round, zb0294)
}
for zb0002 := range (*z).encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedTxnHeaders.FirstValid[zb0002].UnmarshalMsg(bts)
@@ -23530,43 +24839,43 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fvbm":
{
- var zb0280 []byte
- var zb0281 int
- zb0281, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0296 []byte
+ var zb0297 int
+ zb0297, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- if zb0281 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0281), uint64(maxBitmaskSize))
+ if zb0297 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0297), uint64(maxBitmaskSize))
return
}
- zb0280, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFirstValid))
+ zb0296, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- (*z).encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0280)
+ (*z).encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0296)
}
case "lv":
- var zb0282 int
- var zb0283 bool
- zb0282, zb0283, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0298 int
+ var zb0299 bool
+ zb0298, zb0299, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0282 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0282), uint64(maxEncodedTransactionGroups))
+ if zb0298 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0298), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0283 {
+ if zb0299 {
(*z).encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxnHeaders.LastValid) >= zb0282 {
- (*z).encodedTxnHeaders.LastValid = ((*z).encodedTxnHeaders.LastValid)[:zb0282]
+ } else if (*z).encodedTxnHeaders.LastValid != nil && cap((*z).encodedTxnHeaders.LastValid) >= zb0298 {
+ (*z).encodedTxnHeaders.LastValid = ((*z).encodedTxnHeaders.LastValid)[:zb0298]
} else {
- (*z).encodedTxnHeaders.LastValid = make([]basics.Round, zb0282)
+ (*z).encodedTxnHeaders.LastValid = make([]basics.Round, zb0298)
}
for zb0003 := range (*z).encodedTxnHeaders.LastValid {
bts, err = (*z).encodedTxnHeaders.LastValid[zb0003].UnmarshalMsg(bts)
@@ -23577,53 +24886,53 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lvbm":
{
- var zb0284 []byte
- var zb0285 int
- zb0285, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0300 []byte
+ var zb0301 int
+ zb0301, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- if zb0285 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0285), uint64(maxBitmaskSize))
+ if zb0301 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0301), uint64(maxBitmaskSize))
return
}
- zb0284, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLastValid))
+ zb0300, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- (*z).encodedTxnHeaders.BitmaskLastValid = bitmask(zb0284)
+ (*z).encodedTxnHeaders.BitmaskLastValid = bitmask(zb0300)
}
case "note":
- var zb0286 int
- var zb0287 bool
- zb0286, zb0287, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0302 int
+ var zb0303 bool
+ zb0302, zb0303, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Note")
return
}
- if zb0286 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0286), uint64(maxEncodedTransactionGroups))
+ if zb0302 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0302), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Note")
return
}
- if zb0287 {
+ if zb0303 {
(*z).encodedTxnHeaders.Note = nil
- } else if (*z).encodedTxnHeaders.Note != nil && cap((*z).encodedTxnHeaders.Note) >= zb0286 {
- (*z).encodedTxnHeaders.Note = ((*z).encodedTxnHeaders.Note)[:zb0286]
+ } else if (*z).encodedTxnHeaders.Note != nil && cap((*z).encodedTxnHeaders.Note) >= zb0302 {
+ (*z).encodedTxnHeaders.Note = ((*z).encodedTxnHeaders.Note)[:zb0302]
} else {
- (*z).encodedTxnHeaders.Note = make([][]byte, zb0286)
+ (*z).encodedTxnHeaders.Note = make([][]byte, zb0302)
}
for zb0004 := range (*z).encodedTxnHeaders.Note {
- var zb0288 int
- zb0288, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0304 int
+ zb0304, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Note", zb0004)
return
}
- if zb0288 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0288), uint64(config.MaxTxnNoteBytes))
+ if zb0304 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0304), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedTxnHeaders.Note[zb0004], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Note[zb0004])
@@ -23634,73 +24943,73 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "notebm":
{
- var zb0289 []byte
- var zb0290 int
- zb0290, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0305 []byte
+ var zb0306 int
+ zb0306, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- if zb0290 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0290), uint64(maxBitmaskSize))
+ if zb0306 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0306), uint64(maxBitmaskSize))
return
}
- zb0289, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskNote))
+ zb0305, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- (*z).encodedTxnHeaders.BitmaskNote = bitmask(zb0289)
+ (*z).encodedTxnHeaders.BitmaskNote = bitmask(zb0305)
}
case "genbm":
{
- var zb0291 []byte
- var zb0292 int
- zb0292, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0307 []byte
+ var zb0308 int
+ zb0308, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- if zb0292 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0292), uint64(maxBitmaskSize))
+ if zb0308 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0308), uint64(maxBitmaskSize))
return
}
- zb0291, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGenesisID))
+ zb0307, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- (*z).encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0291)
+ (*z).encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0307)
}
case "grpbm":
{
- var zb0293 []byte
- var zb0294 int
- zb0294, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0309 []byte
+ var zb0310 int
+ zb0310, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- if zb0294 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0294), uint64(maxBitmaskSize))
+ if zb0310 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0310), uint64(maxBitmaskSize))
return
}
- zb0293, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGroup))
+ zb0309, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- (*z).encodedTxnHeaders.BitmaskGroup = bitmask(zb0293)
+ (*z).encodedTxnHeaders.BitmaskGroup = bitmask(zb0309)
}
case "lx":
- var zb0295 int
- zb0295, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0311 int
+ zb0311, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Lease")
return
}
- if zb0295 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0295), uint64(maxAddressBytes))
+ if zb0311 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0311), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.Lease)
@@ -23710,33 +25019,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lxbm":
{
- var zb0296 []byte
- var zb0297 int
- zb0297, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0312 []byte
+ var zb0313 int
+ zb0313, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- if zb0297 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0297), uint64(maxBitmaskSize))
+ if zb0313 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0313), uint64(maxBitmaskSize))
return
}
- zb0296, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLease))
+ zb0312, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- (*z).encodedTxnHeaders.BitmaskLease = bitmask(zb0296)
+ (*z).encodedTxnHeaders.BitmaskLease = bitmask(zb0312)
}
case "rekey":
- var zb0298 int
- zb0298, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0314 int
+ zb0314, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "RekeyTo")
return
}
- if zb0298 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0298), uint64(maxAddressBytes))
+ if zb0314 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0314), uint64(maxAddressBytes))
return
}
(*z).encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedTxnHeaders.RekeyTo)
@@ -23746,33 +25055,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rekeybm":
{
- var zb0299 []byte
- var zb0300 int
- zb0300, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0315 []byte
+ var zb0316 int
+ zb0316, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- if zb0300 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0300), uint64(maxBitmaskSize))
+ if zb0316 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0316), uint64(maxBitmaskSize))
return
}
- zb0299, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskRekeyTo))
+ zb0315, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- (*z).encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0299)
+ (*z).encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0315)
}
case "votekey":
- var zb0301 int
- zb0301, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0317 int
+ zb0317, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "VotePK")
return
}
- if zb0301 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0301), uint64(maxAddressBytes))
+ if zb0317 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0317), uint64(maxAddressBytes))
return
}
(*z).encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.VotePK)
@@ -23781,14 +25090,14 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "selkey":
- var zb0302 int
- zb0302, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0318 int
+ zb0318, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "SelectionPK")
return
}
- if zb0302 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0302), uint64(maxAddressBytes))
+ if zb0318 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0318), uint64(maxAddressBytes))
return
}
(*z).encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.SelectionPK)
@@ -23797,24 +25106,24 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "votefst":
- var zb0303 int
- var zb0304 bool
- zb0303, zb0304, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0319 int
+ var zb0320 bool
+ zb0319, zb0320, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0303 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0303), uint64(maxEncodedTransactionGroups))
+ if zb0319 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0319), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0304 {
+ if zb0320 {
(*z).encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedKeyregTxnFields.VoteFirst) >= zb0303 {
- (*z).encodedKeyregTxnFields.VoteFirst = ((*z).encodedKeyregTxnFields.VoteFirst)[:zb0303]
+ } else if (*z).encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedKeyregTxnFields.VoteFirst) >= zb0319 {
+ (*z).encodedKeyregTxnFields.VoteFirst = ((*z).encodedKeyregTxnFields.VoteFirst)[:zb0319]
} else {
- (*z).encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0303)
+ (*z).encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0319)
}
for zb0005 := range (*z).encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedKeyregTxnFields.VoteFirst[zb0005].UnmarshalMsg(bts)
@@ -23825,43 +25134,43 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votefstbm":
{
- var zb0305 []byte
- var zb0306 int
- zb0306, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0321 []byte
+ var zb0322 int
+ zb0322, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- if zb0306 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0306), uint64(maxBitmaskSize))
+ if zb0322 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0322), uint64(maxBitmaskSize))
return
}
- zb0305, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0321, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- (*z).encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0305)
+ (*z).encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0321)
}
case "votelst":
- var zb0307 int
- var zb0308 bool
- zb0307, zb0308, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0323 int
+ var zb0324 bool
+ zb0323, zb0324, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0307 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0307), uint64(maxEncodedTransactionGroups))
+ if zb0323 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0323), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0308 {
+ if zb0324 {
(*z).encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedKeyregTxnFields.VoteLast) >= zb0307 {
- (*z).encodedKeyregTxnFields.VoteLast = ((*z).encodedKeyregTxnFields.VoteLast)[:zb0307]
+ } else if (*z).encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedKeyregTxnFields.VoteLast) >= zb0323 {
+ (*z).encodedKeyregTxnFields.VoteLast = ((*z).encodedKeyregTxnFields.VoteLast)[:zb0323]
} else {
- (*z).encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0307)
+ (*z).encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0323)
}
for zb0006 := range (*z).encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedKeyregTxnFields.VoteLast[zb0006].UnmarshalMsg(bts)
@@ -23872,43 +25181,43 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votelstbm":
{
- var zb0309 []byte
- var zb0310 int
- zb0310, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0325 []byte
+ var zb0326 int
+ zb0326, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- if zb0310 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0310), uint64(maxBitmaskSize))
+ if zb0326 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0326), uint64(maxBitmaskSize))
return
}
- zb0309, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0325, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- (*z).encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0309)
+ (*z).encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0325)
}
case "votekd":
- var zb0311 int
- var zb0312 bool
- zb0311, zb0312, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0327 int
+ var zb0328 bool
+ zb0327, zb0328, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0311 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0311), uint64(maxEncodedTransactionGroups))
+ if zb0327 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0327), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0312 {
+ if zb0328 {
(*z).encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedKeyregTxnFields.VoteKeyDilution) >= zb0311 {
- (*z).encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedKeyregTxnFields.VoteKeyDilution)[:zb0311]
+ } else if (*z).encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedKeyregTxnFields.VoteKeyDilution) >= zb0327 {
+ (*z).encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedKeyregTxnFields.VoteKeyDilution)[:zb0327]
} else {
- (*z).encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0311)
+ (*z).encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0327)
}
for zb0007 := range (*z).encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedKeyregTxnFields.VoteKeyDilution[zb0007], bts, err = msgp.ReadUint64Bytes(bts)
@@ -23919,53 +25228,96 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votekbm":
{
- var zb0313 []byte
- var zb0314 int
- zb0314, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0329 []byte
+ var zb0330 int
+ zb0330, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- if zb0314 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0314), uint64(maxBitmaskSize))
+ if zb0330 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0330), uint64(maxBitmaskSize))
return
}
- zb0313, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskKeys))
+ zb0329, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- (*z).encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0313)
+ (*z).encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0329)
}
case "nonpartbm":
{
- var zb0315 []byte
- var zb0316 int
- zb0316, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0331 []byte
+ var zb0332 int
+ zb0332, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- if zb0316 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0316), uint64(maxBitmaskSize))
+ if zb0332 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0332), uint64(maxBitmaskSize))
return
}
- zb0315, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0331, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- (*z).encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0315)
+ (*z).encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0331)
+ }
+ case "vldrt":
+ var zb0333 int
+ var zb0334 bool
+ zb0333, zb0334, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0333 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0333), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0334 {
+ (*z).encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedKeyregTxnFields.HasValidRoot) >= zb0333 {
+ (*z).encodedKeyregTxnFields.HasValidRoot = ((*z).encodedKeyregTxnFields.HasValidRoot)[:zb0333]
+ } else {
+ (*z).encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0333)
+ }
+ for zb0008 := range (*z).encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedKeyregTxnFields.HasValidRoot[zb0008], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot", zb0008)
+ return
+ }
+ }
+ case "comt":
+ var zb0335 int
+ zb0335, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
+ }
+ if zb0335 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0335), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
}
case "rcv":
- var zb0317 int
- zb0317, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0336 int
+ zb0336, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Receiver")
return
}
- if zb0317 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0317), uint64(maxAddressBytes))
+ if zb0336 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0336), uint64(maxAddressBytes))
return
}
(*z).encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedPaymentTxnFields.Receiver)
@@ -23975,80 +25327,80 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rcvbm":
{
- var zb0318 []byte
- var zb0319 int
- zb0319, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0337 []byte
+ var zb0338 int
+ zb0338, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- if zb0319 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0319), uint64(maxBitmaskSize))
+ if zb0338 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0338), uint64(maxBitmaskSize))
return
}
- zb0318, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskReceiver))
+ zb0337, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- (*z).encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0318)
+ (*z).encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0337)
}
case "amt":
- var zb0320 int
- var zb0321 bool
- zb0320, zb0321, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0339 int
+ var zb0340 bool
+ zb0339, zb0340, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Amount")
return
}
- if zb0320 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0320), uint64(maxEncodedTransactionGroups))
+ if zb0339 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0339), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Amount")
return
}
- if zb0321 {
+ if zb0340 {
(*z).encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedPaymentTxnFields.Amount != nil && cap((*z).encodedPaymentTxnFields.Amount) >= zb0320 {
- (*z).encodedPaymentTxnFields.Amount = ((*z).encodedPaymentTxnFields.Amount)[:zb0320]
+ } else if (*z).encodedPaymentTxnFields.Amount != nil && cap((*z).encodedPaymentTxnFields.Amount) >= zb0339 {
+ (*z).encodedPaymentTxnFields.Amount = ((*z).encodedPaymentTxnFields.Amount)[:zb0339]
} else {
- (*z).encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0320)
+ (*z).encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0339)
}
- for zb0008 := range (*z).encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedPaymentTxnFields.Amount[zb0008].UnmarshalMsg(bts)
+ for zb0009 := range (*z).encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedPaymentTxnFields.Amount[zb0009].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Amount", zb0008)
+ err = msgp.WrapError(err, "Amount", zb0009)
return
}
}
case "amtbm":
{
- var zb0322 []byte
- var zb0323 int
- zb0323, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0341 []byte
+ var zb0342 int
+ zb0342, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- if zb0323 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0323), uint64(maxBitmaskSize))
+ if zb0342 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0342), uint64(maxBitmaskSize))
return
}
- zb0322, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskAmount))
+ zb0341, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- (*z).encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0322)
+ (*z).encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0341)
}
case "close":
- var zb0324 int
- zb0324, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0343 int
+ zb0343, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "CloseRemainderTo")
return
}
- if zb0324 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0324), uint64(maxAddressBytes))
+ if zb0343 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0343), uint64(maxAddressBytes))
return
}
(*z).encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedPaymentTxnFields.CloseRemainderTo)
@@ -24058,335 +25410,335 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "closebm":
{
- var zb0325 []byte
- var zb0326 int
- zb0326, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0344 []byte
+ var zb0345 int
+ zb0345, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- if zb0326 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0326), uint64(maxBitmaskSize))
+ if zb0345 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0345), uint64(maxBitmaskSize))
return
}
- zb0325, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0344, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- (*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0325)
+ (*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0344)
}
case "caid":
- var zb0327 int
- var zb0328 bool
- zb0327, zb0328, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0346 int
+ var zb0347 bool
+ zb0346, zb0347, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0327 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0327), uint64(maxEncodedTransactionGroups))
+ if zb0346 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0346), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0328 {
+ if zb0347 {
(*z).encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedAssetConfigTxnFields.ConfigAsset) >= zb0327 {
- (*z).encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedAssetConfigTxnFields.ConfigAsset)[:zb0327]
+ } else if (*z).encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedAssetConfigTxnFields.ConfigAsset) >= zb0346 {
+ (*z).encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedAssetConfigTxnFields.ConfigAsset)[:zb0346]
} else {
- (*z).encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0327)
+ (*z).encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0346)
}
- for zb0009 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0009].UnmarshalMsg(bts)
+ for zb0010 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0010].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ConfigAsset", zb0009)
+ err = msgp.WrapError(err, "ConfigAsset", zb0010)
return
}
}
case "caidbm":
{
- var zb0329 []byte
- var zb0330 int
- zb0330, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0348 []byte
+ var zb0349 int
+ zb0349, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- if zb0330 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0330), uint64(maxBitmaskSize))
+ if zb0349 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0349), uint64(maxBitmaskSize))
return
}
- zb0329, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0348, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- (*z).encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0329)
+ (*z).encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0348)
}
case "t":
- var zb0331 int
- var zb0332 bool
- zb0331, zb0332, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0350 int
+ var zb0351 bool
+ zb0350, zb0351, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Total")
return
}
- if zb0331 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0331), uint64(maxEncodedTransactionGroups))
+ if zb0350 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0350), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Total")
return
}
- if zb0332 {
+ if zb0351 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0331 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0331]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0350 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0350]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0331)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0350)
}
- for zb0010 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0010], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0011], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Total", zb0010)
+ err = msgp.WrapError(err, "Total", zb0011)
return
}
}
case "tbm":
{
- var zb0333 []byte
- var zb0334 int
- zb0334, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0352 []byte
+ var zb0353 int
+ zb0353, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- if zb0334 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0334), uint64(maxBitmaskSize))
+ if zb0353 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0353), uint64(maxBitmaskSize))
return
}
- zb0333, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0352, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0333)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0352)
}
case "dc":
- var zb0335 int
- var zb0336 bool
- zb0335, zb0336, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0354 int
+ var zb0355 bool
+ zb0354, zb0355, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0335 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0335), uint64(maxEncodedTransactionGroups))
+ if zb0354 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0354), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0336 {
+ if zb0355 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0335 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0335]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0354 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0354]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0335)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0354)
}
- for zb0011 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0011], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0012], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Decimals", zb0011)
+ err = msgp.WrapError(err, "Decimals", zb0012)
return
}
}
case "dcbm":
{
- var zb0337 []byte
- var zb0338 int
- zb0338, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0356 []byte
+ var zb0357 int
+ zb0357, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- if zb0338 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0338), uint64(maxBitmaskSize))
+ if zb0357 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0357), uint64(maxBitmaskSize))
return
}
- zb0337, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0356, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0337)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0356)
}
case "dfbm":
{
- var zb0339 []byte
- var zb0340 int
- zb0340, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0358 []byte
+ var zb0359 int
+ zb0359, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- if zb0340 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0340), uint64(maxBitmaskSize))
+ if zb0359 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0359), uint64(maxBitmaskSize))
return
}
- zb0339, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0358, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0339)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0358)
}
case "un":
- var zb0341 int
- var zb0342 bool
- zb0341, zb0342, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0360 int
+ var zb0361 bool
+ zb0360, zb0361, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0341 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0341), uint64(maxEncodedTransactionGroups))
+ if zb0360 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0360), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0342 {
+ if zb0361 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0341 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0341]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0360 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0360]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0341)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0360)
}
- for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0012], bts, err = msgp.ReadStringBytes(bts)
+ for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0013], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "UnitName", zb0012)
+ err = msgp.WrapError(err, "UnitName", zb0013)
return
}
}
case "unbm":
{
- var zb0343 []byte
- var zb0344 int
- zb0344, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0362 []byte
+ var zb0363 int
+ zb0363, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- if zb0344 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0344), uint64(maxBitmaskSize))
+ if zb0363 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0363), uint64(maxBitmaskSize))
return
}
- zb0343, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0362, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0343)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0362)
}
case "an":
- var zb0345 int
- var zb0346 bool
- zb0345, zb0346, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0364 int
+ var zb0365 bool
+ zb0364, zb0365, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0345 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0345), uint64(maxEncodedTransactionGroups))
+ if zb0364 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0364), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0346 {
+ if zb0365 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0345 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0345]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0364 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0364]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0345)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0364)
}
- for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0013], bts, err = msgp.ReadStringBytes(bts)
+ for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0014], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetName", zb0013)
+ err = msgp.WrapError(err, "AssetName", zb0014)
return
}
}
case "anbm":
{
- var zb0347 []byte
- var zb0348 int
- zb0348, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0366 []byte
+ var zb0367 int
+ zb0367, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- if zb0348 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0348), uint64(maxBitmaskSize))
+ if zb0367 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0367), uint64(maxBitmaskSize))
return
}
- zb0347, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0366, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0347)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0366)
}
case "au":
- var zb0349 int
- var zb0350 bool
- zb0349, zb0350, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0368 int
+ var zb0369 bool
+ zb0368, zb0369, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "URL")
return
}
- if zb0349 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0349), uint64(maxEncodedTransactionGroups))
+ if zb0368 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0368), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "URL")
return
}
- if zb0350 {
+ if zb0369 {
(*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0349 {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0349]
+ } else if (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0368 {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0368]
} else {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0349)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0368)
}
- for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0014], bts, err = msgp.ReadStringBytes(bts)
+ for zb0015 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0015], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "URL", zb0014)
+ err = msgp.WrapError(err, "URL", zb0015)
return
}
}
case "aubm":
{
- var zb0351 []byte
- var zb0352 int
- zb0352, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0370 []byte
+ var zb0371 int
+ zb0371, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- if zb0352 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0352), uint64(maxBitmaskSize))
+ if zb0371 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0371), uint64(maxBitmaskSize))
return
}
- zb0351, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0370, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0351)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0370)
}
case "am":
- var zb0353 int
- zb0353, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0372 int
+ zb0372, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "MetadataHash")
return
}
- if zb0353 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0353), uint64(maxAddressBytes))
+ if zb0372 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0372), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -24396,33 +25748,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "ambm":
{
- var zb0354 []byte
- var zb0355 int
- zb0355, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0373 []byte
+ var zb0374 int
+ zb0374, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- if zb0355 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0355), uint64(maxBitmaskSize))
+ if zb0374 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0374), uint64(maxBitmaskSize))
return
}
- zb0354, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0373, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0354)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0373)
}
case "m":
- var zb0356 int
- zb0356, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0375 int
+ zb0375, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Manager")
return
}
- if zb0356 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0356), uint64(maxAddressBytes))
+ if zb0375 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0375), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -24432,33 +25784,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "mbm":
{
- var zb0357 []byte
- var zb0358 int
- zb0358, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0376 []byte
+ var zb0377 int
+ zb0377, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- if zb0358 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0358), uint64(maxBitmaskSize))
+ if zb0377 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0377), uint64(maxBitmaskSize))
return
}
- zb0357, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0376, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0357)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0376)
}
case "r":
- var zb0359 int
- zb0359, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0378 int
+ zb0378, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Reserve")
return
}
- if zb0359 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0359), uint64(maxAddressBytes))
+ if zb0378 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0378), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -24468,33 +25820,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rbm":
{
- var zb0360 []byte
- var zb0361 int
- zb0361, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0379 []byte
+ var zb0380 int
+ zb0380, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- if zb0361 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0361), uint64(maxBitmaskSize))
+ if zb0380 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0380), uint64(maxBitmaskSize))
return
}
- zb0360, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0379, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0360)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0379)
}
case "f":
- var zb0362 int
- zb0362, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0381 int
+ zb0381, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Freeze")
return
}
- if zb0362 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0362), uint64(maxAddressBytes))
+ if zb0381 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0381), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -24504,33 +25856,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fbm":
{
- var zb0363 []byte
- var zb0364 int
- zb0364, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0382 []byte
+ var zb0383 int
+ zb0383, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- if zb0364 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0364), uint64(maxBitmaskSize))
+ if zb0383 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0383), uint64(maxBitmaskSize))
return
}
- zb0363, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0382, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0363)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0382)
}
case "c":
- var zb0365 int
- zb0365, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0384 int
+ zb0384, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Clawback")
return
}
- if zb0365 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0365), uint64(maxAddressBytes))
+ if zb0384 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0384), uint64(maxAddressBytes))
return
}
(*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -24540,127 +25892,127 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "cbm":
{
- var zb0366 []byte
- var zb0367 int
- zb0367, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0385 []byte
+ var zb0386 int
+ zb0386, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- if zb0367 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0367), uint64(maxBitmaskSize))
+ if zb0386 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0386), uint64(maxBitmaskSize))
return
}
- zb0366, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0385, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0366)
+ (*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0385)
}
case "xaid":
- var zb0368 int
- var zb0369 bool
- zb0368, zb0369, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0387 int
+ var zb0388 bool
+ zb0387, zb0388, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0368 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0368), uint64(maxEncodedTransactionGroups))
+ if zb0387 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0387), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0369 {
+ if zb0388 {
(*z).encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedAssetTransferTxnFields.XferAsset) >= zb0368 {
- (*z).encodedAssetTransferTxnFields.XferAsset = ((*z).encodedAssetTransferTxnFields.XferAsset)[:zb0368]
+ } else if (*z).encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedAssetTransferTxnFields.XferAsset) >= zb0387 {
+ (*z).encodedAssetTransferTxnFields.XferAsset = ((*z).encodedAssetTransferTxnFields.XferAsset)[:zb0387]
} else {
- (*z).encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0368)
+ (*z).encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0387)
}
- for zb0015 := range (*z).encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedAssetTransferTxnFields.XferAsset[zb0015].UnmarshalMsg(bts)
+ for zb0016 := range (*z).encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedAssetTransferTxnFields.XferAsset[zb0016].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "XferAsset", zb0015)
+ err = msgp.WrapError(err, "XferAsset", zb0016)
return
}
}
case "xaidbm":
{
- var zb0370 []byte
- var zb0371 int
- zb0371, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0389 []byte
+ var zb0390 int
+ zb0390, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- if zb0371 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0371), uint64(maxBitmaskSize))
+ if zb0390 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0390), uint64(maxBitmaskSize))
return
}
- zb0370, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0389, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0370)
+ (*z).encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0389)
}
case "aamt":
- var zb0372 int
- var zb0373 bool
- zb0372, zb0373, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0391 int
+ var zb0392 bool
+ zb0391, zb0392, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0372 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0372), uint64(maxEncodedTransactionGroups))
+ if zb0391 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0391), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0373 {
+ if zb0392 {
(*z).encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedAssetTransferTxnFields.AssetAmount) >= zb0372 {
- (*z).encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedAssetTransferTxnFields.AssetAmount)[:zb0372]
+ } else if (*z).encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedAssetTransferTxnFields.AssetAmount) >= zb0391 {
+ (*z).encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedAssetTransferTxnFields.AssetAmount)[:zb0391]
} else {
- (*z).encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0372)
+ (*z).encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0391)
}
- for zb0016 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedAssetTransferTxnFields.AssetAmount[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0017 := range (*z).encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedAssetTransferTxnFields.AssetAmount[zb0017], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetAmount", zb0016)
+ err = msgp.WrapError(err, "AssetAmount", zb0017)
return
}
}
case "aamtbm":
{
- var zb0374 []byte
- var zb0375 int
- zb0375, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0393 []byte
+ var zb0394 int
+ zb0394, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- if zb0375 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0375), uint64(maxBitmaskSize))
+ if zb0394 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0394), uint64(maxBitmaskSize))
return
}
- zb0374, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0393, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0374)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0393)
}
case "asnd":
- var zb0376 int
- zb0376, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0395 int
+ zb0395, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetSender")
return
}
- if zb0376 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0376), uint64(maxAddressBytes))
+ if zb0395 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0395), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetSender)
@@ -24670,33 +26022,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "asndbm":
{
- var zb0377 []byte
- var zb0378 int
- zb0378, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0396 []byte
+ var zb0397 int
+ zb0397, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- if zb0378 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0378), uint64(maxBitmaskSize))
+ if zb0397 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0397), uint64(maxBitmaskSize))
return
}
- zb0377, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0396, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0377)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0396)
}
case "arcv":
- var zb0379 int
- zb0379, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0398 int
+ zb0398, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetReceiver")
return
}
- if zb0379 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0379), uint64(maxAddressBytes))
+ if zb0398 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0398), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetReceiver)
@@ -24706,33 +26058,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "arcvbm":
{
- var zb0380 []byte
- var zb0381 int
- zb0381, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0399 []byte
+ var zb0400 int
+ zb0400, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- if zb0381 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0381), uint64(maxBitmaskSize))
+ if zb0400 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0400), uint64(maxBitmaskSize))
return
}
- zb0380, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0399, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0380)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0399)
}
case "aclose":
- var zb0382 int
- zb0382, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0401 int
+ zb0401, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetCloseTo")
return
}
- if zb0382 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0382), uint64(maxAddressBytes))
+ if zb0401 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0401), uint64(maxAddressBytes))
return
}
(*z).encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetTransferTxnFields.AssetCloseTo)
@@ -24742,33 +26094,33 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "aclosebm":
{
- var zb0383 []byte
- var zb0384 int
- zb0384, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0402 []byte
+ var zb0403 int
+ zb0403, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- if zb0384 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0384), uint64(maxBitmaskSize))
+ if zb0403 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0403), uint64(maxBitmaskSize))
return
}
- zb0383, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0402, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- (*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0383)
+ (*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0402)
}
case "fadd":
- var zb0385 int
- zb0385, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0404 int
+ zb0404, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAccount")
return
}
- if zb0385 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0385), uint64(maxAddressBytes))
+ if zb0404 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0404), uint64(maxAddressBytes))
return
}
(*z).encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedAssetFreezeTxnFields.FreezeAccount)
@@ -24778,147 +26130,147 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "faddbm":
{
- var zb0386 []byte
- var zb0387 int
- zb0387, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0405 []byte
+ var zb0406 int
+ zb0406, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- if zb0387 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0387), uint64(maxBitmaskSize))
+ if zb0406 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0406), uint64(maxBitmaskSize))
return
}
- zb0386, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0405, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0386)
+ (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0405)
}
case "faid":
- var zb0388 int
- var zb0389 bool
- zb0388, zb0389, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0407 int
+ var zb0408 bool
+ zb0407, zb0408, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0388 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0388), uint64(maxEncodedTransactionGroups))
+ if zb0407 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0407), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0389 {
+ if zb0408 {
(*z).encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedAssetFreezeTxnFields.FreezeAsset) >= zb0388 {
- (*z).encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedAssetFreezeTxnFields.FreezeAsset)[:zb0388]
+ } else if (*z).encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedAssetFreezeTxnFields.FreezeAsset) >= zb0407 {
+ (*z).encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedAssetFreezeTxnFields.FreezeAsset)[:zb0407]
} else {
- (*z).encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0388)
+ (*z).encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0407)
}
- for zb0017 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0017].UnmarshalMsg(bts)
+ for zb0018 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0018].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "FreezeAsset", zb0017)
+ err = msgp.WrapError(err, "FreezeAsset", zb0018)
return
}
}
case "faidbm":
{
- var zb0390 []byte
- var zb0391 int
- zb0391, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0409 []byte
+ var zb0410 int
+ zb0410, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- if zb0391 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0391), uint64(maxBitmaskSize))
+ if zb0410 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0410), uint64(maxBitmaskSize))
return
}
- zb0390, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0409, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0390)
+ (*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0409)
}
case "afrzbm":
{
- var zb0392 []byte
- var zb0393 int
- zb0393, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0411 []byte
+ var zb0412 int
+ zb0412, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- if zb0393 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0393), uint64(maxBitmaskSize))
+ if zb0412 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0412), uint64(maxBitmaskSize))
return
}
- zb0392, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0411, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- (*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0392)
+ (*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0411)
}
case "apid":
- var zb0394 int
- var zb0395 bool
- zb0394, zb0395, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0413 int
+ var zb0414 bool
+ zb0413, zb0414, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0394 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0394), uint64(maxEncodedTransactionGroups))
+ if zb0413 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0413), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0395 {
+ if zb0414 {
(*z).encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationID) >= zb0394 {
- (*z).encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedApplicationCallTxnFields.ApplicationID)[:zb0394]
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationID) >= zb0413 {
+ (*z).encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedApplicationCallTxnFields.ApplicationID)[:zb0413]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0394)
+ (*z).encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0413)
}
- for zb0018 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0018].UnmarshalMsg(bts)
+ for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedApplicationCallTxnFields.ApplicationID[zb0019].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationID", zb0018)
+ err = msgp.WrapError(err, "ApplicationID", zb0019)
return
}
}
case "apidbm":
{
- var zb0396 []byte
- var zb0397 int
- zb0397, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0415 []byte
+ var zb0416 int
+ zb0416, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- if zb0397 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0397), uint64(maxBitmaskSize))
+ if zb0416 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0416), uint64(maxBitmaskSize))
return
}
- zb0396, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0415, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0396)
+ (*z).encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0415)
}
case "apan":
- var zb0398 int
- zb0398, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0417 int
+ zb0417, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "OnCompletion")
return
}
- if zb0398 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0398), uint64(maxEncodedTransactionGroups))
+ if zb0417 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0417), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.OnCompletion)
@@ -24928,1040 +26280,1145 @@ func (z *encodedTxns) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "apanbm":
{
- var zb0399 []byte
- var zb0400 int
- zb0400, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0418 []byte
+ var zb0419 int
+ zb0419, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- if zb0400 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0400), uint64(maxBitmaskSize))
+ if zb0419 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0419), uint64(maxBitmaskSize))
return
}
- zb0399, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0418, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0399)
+ (*z).encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0418)
}
case "apaa":
- var zb0401 int
- var zb0402 bool
- zb0401, zb0402, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0420 int
+ var zb0421 bool
+ zb0420, zb0421, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0401 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0401), uint64(maxEncodedTransactionGroups))
+ if zb0420 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0420), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0402 {
+ if zb0421 {
(*z).encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs) >= zb0401 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedApplicationCallTxnFields.ApplicationArgs)[:zb0401]
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs) >= zb0420 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedApplicationCallTxnFields.ApplicationArgs)[:zb0420]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0401)
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0420)
}
- for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0403 int
- var zb0404 bool
- zb0403, zb0404, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0422 int
+ var zb0423 bool
+ zb0422, zb0423, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0019)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0020)
return
}
- if zb0403 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0403), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "ApplicationArgs", zb0019)
+ if zb0422 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0422), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "ApplicationArgs", zb0020)
return
}
- if zb0404 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = nil
- } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019]) >= zb0403 {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = ((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019])[:zb0403]
+ if zb0423 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] != nil && cap((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020]) >= zb0422 {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = ((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020])[:zb0422]
} else {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] = make(applicationArgs, zb0403)
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] = make(applicationArgs, zb0422)
}
- for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] {
- (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020])
+ for zb0021 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] {
+ (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021])
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0019, zb0020)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0020, zb0021)
return
}
}
}
case "apaabm":
{
- var zb0405 []byte
- var zb0406 int
- zb0406, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0424 []byte
+ var zb0425 int
+ zb0425, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- if zb0406 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0406), uint64(maxBitmaskSize))
+ if zb0425 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0425), uint64(maxBitmaskSize))
return
}
- zb0405, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0424, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0405)
+ (*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0424)
}
case "apat":
- var zb0407 int
- var zb0408 bool
- zb0407, zb0408, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0426 int
+ var zb0427 bool
+ zb0426, zb0427, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0407 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0407), uint64(maxEncodedTransactionGroups))
+ if zb0426 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0426), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0408 {
+ if zb0427 {
(*z).encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedApplicationCallTxnFields.Accounts) >= zb0407 {
- (*z).encodedApplicationCallTxnFields.Accounts = ((*z).encodedApplicationCallTxnFields.Accounts)[:zb0407]
+ } else if (*z).encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedApplicationCallTxnFields.Accounts) >= zb0426 {
+ (*z).encodedApplicationCallTxnFields.Accounts = ((*z).encodedApplicationCallTxnFields.Accounts)[:zb0426]
} else {
- (*z).encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0407)
+ (*z).encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0426)
}
- for zb0021 := range (*z).encodedApplicationCallTxnFields.Accounts {
- var zb0409 int
- var zb0410 bool
- zb0409, zb0410, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts {
+ var zb0428 int
+ var zb0429 bool
+ zb0428, zb0429, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0021)
+ err = msgp.WrapError(err, "Accounts", zb0022)
return
}
- if zb0409 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0409), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "Accounts", zb0021)
+ if zb0428 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0428), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "Accounts", zb0022)
return
}
- if zb0410 {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = nil
- } else if (*z).encodedApplicationCallTxnFields.Accounts[zb0021] != nil && cap((*z).encodedApplicationCallTxnFields.Accounts[zb0021]) >= zb0409 {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = ((*z).encodedApplicationCallTxnFields.Accounts[zb0021])[:zb0409]
+ if zb0429 {
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = nil
+ } else if (*z).encodedApplicationCallTxnFields.Accounts[zb0022] != nil && cap((*z).encodedApplicationCallTxnFields.Accounts[zb0022]) >= zb0428 {
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = ((*z).encodedApplicationCallTxnFields.Accounts[zb0022])[:zb0428]
} else {
- (*z).encodedApplicationCallTxnFields.Accounts[zb0021] = make(addresses, zb0409)
+ (*z).encodedApplicationCallTxnFields.Accounts[zb0022] = make(addresses, zb0428)
}
- for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0021] {
- bts, err = (*z).encodedApplicationCallTxnFields.Accounts[zb0021][zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0022] {
+ bts, err = (*z).encodedApplicationCallTxnFields.Accounts[zb0022][zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0021, zb0022)
+ err = msgp.WrapError(err, "Accounts", zb0022, zb0023)
return
}
}
}
case "apatbm":
{
- var zb0411 []byte
- var zb0412 int
- zb0412, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0430 []byte
+ var zb0431 int
+ zb0431, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- if zb0412 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0412), uint64(maxBitmaskSize))
+ if zb0431 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0431), uint64(maxBitmaskSize))
return
}
- zb0411, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0430, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0411)
+ (*z).encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0430)
}
case "apfa":
- var zb0413 int
- var zb0414 bool
- zb0413, zb0414, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0432 int
+ var zb0433 bool
+ zb0432, zb0433, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0413 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0413), uint64(maxEncodedTransactionGroups))
+ if zb0432 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0432), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0414 {
+ if zb0433 {
(*z).encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps) >= zb0413 {
- (*z).encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedApplicationCallTxnFields.ForeignApps)[:zb0413]
+ } else if (*z).encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps) >= zb0432 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedApplicationCallTxnFields.ForeignApps)[:zb0432]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0413)
+ (*z).encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0432)
}
- for zb0023 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
- var zb0415 int
- var zb0416 bool
- zb0415, zb0416, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
+ var zb0434 int
+ var zb0435 bool
+ zb0434, zb0435, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0023)
+ err = msgp.WrapError(err, "ForeignApps", zb0024)
return
}
- if zb0415 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0415), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "ForeignApps", zb0023)
+ if zb0434 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0434), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "ForeignApps", zb0024)
return
}
- if zb0416 {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps[zb0023]) >= zb0415 {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = ((*z).encodedApplicationCallTxnFields.ForeignApps[zb0023])[:zb0415]
+ if zb0435 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignApps[zb0024]) >= zb0434 {
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = ((*z).encodedApplicationCallTxnFields.ForeignApps[zb0024])[:zb0434]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] = make(appIndices, zb0415)
+ (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] = make(appIndices, zb0434)
}
- for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] {
- bts, err = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023][zb0024].UnmarshalMsg(bts)
+ for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] {
+ bts, err = (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024][zb0025].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0023, zb0024)
+ err = msgp.WrapError(err, "ForeignApps", zb0024, zb0025)
return
}
}
}
case "apfabm":
{
- var zb0417 []byte
- var zb0418 int
- zb0418, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0436 []byte
+ var zb0437 int
+ zb0437, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- if zb0418 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0418), uint64(maxBitmaskSize))
+ if zb0437 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0437), uint64(maxBitmaskSize))
return
}
- zb0417, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0436, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0417)
+ (*z).encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0436)
}
case "apas":
- var zb0419 int
- var zb0420 bool
- zb0419, zb0420, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0438 int
+ var zb0439 bool
+ zb0438, zb0439, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0419 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0419), uint64(maxEncodedTransactionGroups))
+ if zb0438 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0438), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0420 {
+ if zb0439 {
(*z).encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets) >= zb0419 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedApplicationCallTxnFields.ForeignAssets)[:zb0419]
+ } else if (*z).encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets) >= zb0438 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedApplicationCallTxnFields.ForeignAssets)[:zb0438]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0419)
+ (*z).encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0438)
}
- for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
- var zb0421 int
- var zb0422 bool
- zb0421, zb0422, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0440 int
+ var zb0441 bool
+ zb0440, zb0441, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0025)
+ err = msgp.WrapError(err, "ForeignAssets", zb0026)
return
}
- if zb0421 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0421), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "ForeignAssets", zb0025)
+ if zb0440 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0440), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "ForeignAssets", zb0026)
return
}
- if zb0422 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = nil
- } else if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025]) >= zb0421 {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = ((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025])[:zb0421]
+ if zb0441 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = nil
+ } else if (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] != nil && cap((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026]) >= zb0440 {
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = ((*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026])[:zb0440]
} else {
- (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] = make(assetIndices, zb0421)
+ (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] = make(assetIndices, zb0440)
}
- for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] {
- bts, err = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025][zb0026].UnmarshalMsg(bts)
+ for zb0027 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] {
+ bts, err = (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026][zb0027].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0025, zb0026)
+ err = msgp.WrapError(err, "ForeignAssets", zb0026, zb0027)
return
}
}
}
case "apasbm":
{
- var zb0423 []byte
- var zb0424 int
- zb0424, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0442 []byte
+ var zb0443 int
+ zb0443, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- if zb0424 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0424), uint64(maxBitmaskSize))
+ if zb0443 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0443), uint64(maxBitmaskSize))
return
}
- zb0423, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0442, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0423)
+ (*z).encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0442)
}
case "lnui":
- var zb0425 int
- var zb0426 bool
- zb0425, zb0426, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0444 int
+ var zb0445 bool
+ zb0444, zb0445, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0425 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0425), uint64(maxEncodedTransactionGroups))
+ if zb0444 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0444), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0426 {
+ if zb0445 {
(*z).encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumUint) >= zb0425 {
- (*z).encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedApplicationCallTxnFields.LocalNumUint)[:zb0425]
+ } else if (*z).encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumUint) >= zb0444 {
+ (*z).encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedApplicationCallTxnFields.LocalNumUint)[:zb0444]
} else {
- (*z).encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0425)
+ (*z).encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0444)
}
- for zb0027 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0027], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedApplicationCallTxnFields.LocalNumUint[zb0028], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumUint", zb0027)
+ err = msgp.WrapError(err, "LocalNumUint", zb0028)
return
}
}
case "lnuibm":
{
- var zb0427 []byte
- var zb0428 int
- zb0428, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0446 []byte
+ var zb0447 int
+ zb0447, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- if zb0428 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0428), uint64(maxBitmaskSize))
+ if zb0447 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0447), uint64(maxBitmaskSize))
return
}
- zb0427, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0446, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0427)
+ (*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0446)
}
case "lnbs":
- var zb0429 int
- var zb0430 bool
- zb0429, zb0430, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0448 int
+ var zb0449 bool
+ zb0448, zb0449, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0429 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0429), uint64(maxEncodedTransactionGroups))
+ if zb0448 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0448), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0430 {
+ if zb0449 {
(*z).encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0429 {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0429]
+ } else if (*z).encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0448 {
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0448]
} else {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0429)
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0448)
}
- for zb0028 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0028], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0029 := range (*z).encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedApplicationCallTxnFields.LocalNumByteSlice[zb0029], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumByteSlice", zb0028)
+ err = msgp.WrapError(err, "LocalNumByteSlice", zb0029)
return
}
}
case "lnbsbm":
{
- var zb0431 []byte
- var zb0432 int
- zb0432, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0450 []byte
+ var zb0451 int
+ zb0451, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- if zb0432 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0432), uint64(maxBitmaskSize))
+ if zb0451 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0451), uint64(maxBitmaskSize))
return
}
- zb0431, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0450, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0431)
+ (*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0450)
}
case "gnui":
- var zb0433 int
- var zb0434 bool
- zb0433, zb0434, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0452 int
+ var zb0453 bool
+ zb0452, zb0453, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0433 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0433), uint64(maxEncodedTransactionGroups))
+ if zb0452 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0452), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0434 {
+ if zb0453 {
(*z).encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumUint) >= zb0433 {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedApplicationCallTxnFields.GlobalNumUint)[:zb0433]
+ } else if (*z).encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumUint) >= zb0452 {
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedApplicationCallTxnFields.GlobalNumUint)[:zb0452]
} else {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0433)
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0452)
}
- for zb0029 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0029], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedApplicationCallTxnFields.GlobalNumUint[zb0030], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumUint", zb0029)
+ err = msgp.WrapError(err, "GlobalNumUint", zb0030)
return
}
}
case "gnuibm":
{
- var zb0435 []byte
- var zb0436 int
- zb0436, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0454 []byte
+ var zb0455 int
+ zb0455, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- if zb0436 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0436), uint64(maxBitmaskSize))
+ if zb0455 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0455), uint64(maxBitmaskSize))
return
}
- zb0435, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0454, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0435)
+ (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0454)
}
case "gnbs":
- var zb0437 int
- var zb0438 bool
- zb0437, zb0438, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0456 int
+ var zb0457 bool
+ zb0456, zb0457, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0437 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0437), uint64(maxEncodedTransactionGroups))
+ if zb0456 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0456), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0438 {
+ if zb0457 {
(*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0437 {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0437]
+ } else if (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0456 {
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0456]
} else {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0437)
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0456)
}
- for zb0030 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0030], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0031 := range (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0031], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumByteSlice", zb0030)
+ err = msgp.WrapError(err, "GlobalNumByteSlice", zb0031)
return
}
}
case "gnbsbm":
{
- var zb0439 []byte
- var zb0440 int
- zb0440, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0458 []byte
+ var zb0459 int
+ zb0459, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- if zb0440 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0440), uint64(maxBitmaskSize))
+ if zb0459 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0459), uint64(maxBitmaskSize))
return
}
- zb0439, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0458, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0439)
+ (*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0458)
}
case "apap":
- var zb0441 int
- var zb0442 bool
- zb0441, zb0442, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0460 int
+ var zb0461 bool
+ zb0460, zb0461, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0441 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0441), uint64(maxEncodedTransactionGroups))
+ if zb0460 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0460), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0442 {
+ if zb0461 {
(*z).encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedApplicationCallTxnFields.ApprovalProgram) >= zb0441 {
- (*z).encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedApplicationCallTxnFields.ApprovalProgram)[:zb0441]
+ } else if (*z).encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedApplicationCallTxnFields.ApprovalProgram) >= zb0460 {
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedApplicationCallTxnFields.ApprovalProgram)[:zb0460]
} else {
- (*z).encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0441)
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0460)
}
- for zb0031 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0032 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0443 []byte
- var zb0444 int
- zb0444, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0462 []byte
+ var zb0463 int
+ zb0463, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0031)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0032)
return
}
- if zb0444 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0444), uint64(config.MaxAvailableAppProgramLen))
+ if zb0463 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0463), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0443, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031]))
+ zb0462, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032]))
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0031)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0032)
return
}
- (*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031] = program(zb0443)
+ (*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032] = program(zb0462)
}
}
case "apapbm":
{
- var zb0445 []byte
- var zb0446 int
- zb0446, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0464 []byte
+ var zb0465 int
+ zb0465, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- if zb0446 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0446), uint64(maxBitmaskSize))
+ if zb0465 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0465), uint64(maxBitmaskSize))
return
}
- zb0445, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0464, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0445)
+ (*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0464)
}
case "apsu":
- var zb0447 int
- var zb0448 bool
- zb0447, zb0448, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0466 int
+ var zb0467 bool
+ zb0466, zb0467, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0447 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0447), uint64(maxEncodedTransactionGroups))
+ if zb0466 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0466), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0448 {
+ if zb0467 {
(*z).encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedApplicationCallTxnFields.ClearStateProgram) >= zb0447 {
- (*z).encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedApplicationCallTxnFields.ClearStateProgram)[:zb0447]
+ } else if (*z).encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedApplicationCallTxnFields.ClearStateProgram) >= zb0466 {
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedApplicationCallTxnFields.ClearStateProgram)[:zb0466]
} else {
- (*z).encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0447)
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0466)
}
- for zb0032 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0033 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0449 []byte
- var zb0450 int
- zb0450, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0468 []byte
+ var zb0469 int
+ zb0469, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0032)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0033)
return
}
- if zb0450 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0450), uint64(config.MaxAvailableAppProgramLen))
+ if zb0469 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0469), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0449, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032]))
+ zb0468, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033]))
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0032)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0033)
return
}
- (*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032] = program(zb0449)
+ (*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033] = program(zb0468)
}
}
case "apsubm":
{
- var zb0451 []byte
- var zb0452 int
- zb0452, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0470 []byte
+ var zb0471 int
+ zb0471, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- if zb0452 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0452), uint64(maxBitmaskSize))
+ if zb0471 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0471), uint64(maxBitmaskSize))
return
}
- zb0451, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0470, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0451)
+ (*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0470)
}
case "apep":
- var zb0453 int
- var zb0454 bool
- zb0453, zb0454, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0472 int
+ var zb0473 bool
+ zb0472, zb0473, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0453 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0453), uint64(maxEncodedTransactionGroups))
+ if zb0472 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0472), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0454 {
+ if zb0473 {
(*z).encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0453 {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0453]
+ } else if (*z).encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0472 {
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0472]
} else {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0453)
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0472)
}
- for zb0033 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0033], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0034 := range (*z).encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedApplicationCallTxnFields.ExtraProgramPages[zb0034], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ExtraProgramPages", zb0033)
+ err = msgp.WrapError(err, "ExtraProgramPages", zb0034)
return
}
}
case "apepbm":
{
- var zb0455 []byte
- var zb0456 int
- zb0456, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0474 []byte
+ var zb0475 int
+ zb0475, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- if zb0456 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0456), uint64(maxBitmaskSize))
+ if zb0475 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0475), uint64(maxBitmaskSize))
return
}
- zb0455, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0474, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- (*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0455)
+ (*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0474)
}
case "certrnd":
- var zb0457 int
- var zb0458 bool
- zb0457, zb0458, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0476 int
+ var zb0477 bool
+ zb0476, zb0477, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0457 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0457), uint64(maxEncodedTransactionGroups))
+ if zb0476 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0476), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0458 {
+ if zb0477 {
(*z).encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedCompactCertTxnFields.CertRound) >= zb0457 {
- (*z).encodedCompactCertTxnFields.CertRound = ((*z).encodedCompactCertTxnFields.CertRound)[:zb0457]
+ } else if (*z).encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedCompactCertTxnFields.CertRound) >= zb0476 {
+ (*z).encodedCompactCertTxnFields.CertRound = ((*z).encodedCompactCertTxnFields.CertRound)[:zb0476]
} else {
- (*z).encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0457)
+ (*z).encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0476)
}
- for zb0034 := range (*z).encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedCompactCertTxnFields.CertRound[zb0034].UnmarshalMsg(bts)
+ for zb0035 := range (*z).encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedCompactCertTxnFields.CertRound[zb0035].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertRound", zb0034)
+ err = msgp.WrapError(err, "CertRound", zb0035)
return
}
}
case "certrndbm":
{
- var zb0459 []byte
- var zb0460 int
- zb0460, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0478 []byte
+ var zb0479 int
+ zb0479, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- if zb0460 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0460), uint64(maxBitmaskSize))
+ if zb0479 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0479), uint64(maxBitmaskSize))
return
}
- zb0459, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0478, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- (*z).encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0459)
+ (*z).encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0478)
}
case "certtype":
- var zb0461 int
- var zb0462 bool
- zb0461, zb0462, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0480 int
+ var zb0481 bool
+ zb0480, zb0481, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertType")
return
}
- if zb0461 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0461), uint64(maxEncodedTransactionGroups))
+ if zb0480 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0480), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertType")
return
}
- if zb0462 {
+ if zb0481 {
(*z).encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedCompactCertTxnFields.CertType) >= zb0461 {
- (*z).encodedCompactCertTxnFields.CertType = ((*z).encodedCompactCertTxnFields.CertType)[:zb0461]
+ } else if (*z).encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedCompactCertTxnFields.CertType) >= zb0480 {
+ (*z).encodedCompactCertTxnFields.CertType = ((*z).encodedCompactCertTxnFields.CertType)[:zb0480]
} else {
- (*z).encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0461)
+ (*z).encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0480)
}
- for zb0035 := range (*z).encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedCompactCertTxnFields.CertType[zb0035].UnmarshalMsg(bts)
+ for zb0036 := range (*z).encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedCompactCertTxnFields.CertType[zb0036].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertType", zb0035)
+ err = msgp.WrapError(err, "CertType", zb0036)
return
}
}
case "certtypebm":
{
- var zb0463 []byte
- var zb0464 int
- zb0464, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0482 []byte
+ var zb0483 int
+ zb0483, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- if zb0464 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0464), uint64(maxBitmaskSize))
+ if zb0483 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0483), uint64(maxBitmaskSize))
return
}
- zb0463, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertType))
+ zb0482, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- (*z).encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0463)
+ (*z).encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0482)
}
case "certc":
- var zb0465 int
- zb0465, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0484 int
+ var zb0485 bool
+ zb0484, zb0485, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigCommit")
return
}
- if zb0465 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0465), uint64(maxAddressBytes))
- return
- }
- (*z).encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0484 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0484), uint64(maxAddressBytes))
err = msgp.WrapError(err, "SigCommit")
return
}
+ if zb0485 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0484 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0484]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0484)
+ }
+ for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigCommit[zb0037].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigCommit", zb0037)
+ return
+ }
+ }
case "certcbm":
{
- var zb0466 []byte
- var zb0467 int
- zb0467, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0486 []byte
+ var zb0487 int
+ zb0487, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- if zb0467 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0467), uint64(maxBitmaskSize))
+ if zb0487 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0487), uint64(maxBitmaskSize))
return
}
- zb0466, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0486, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0466)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0486)
}
case "certw":
- var zb0468 int
- var zb0469 bool
- zb0468, zb0469, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0488 int
+ var zb0489 bool
+ zb0488, zb0489, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0468 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0468), uint64(maxEncodedTransactionGroups))
+ if zb0488 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0488), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0469 {
+ if zb0489 {
(*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0468 {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0468]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0488 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0488]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0468)
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0488)
}
- for zb0036 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0038], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SignedWeight", zb0036)
+ err = msgp.WrapError(err, "SignedWeight", zb0038)
return
}
}
case "certwbm":
{
- var zb0470 []byte
- var zb0471 int
- zb0471, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0490 []byte
+ var zb0491 int
+ zb0491, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- if zb0471 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0471), uint64(maxBitmaskSize))
+ if zb0491 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0491), uint64(maxBitmaskSize))
return
}
- zb0470, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0490, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0470)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0490)
}
case "certS":
- var zb0472 int
- var zb0473 bool
- zb0472, zb0473, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0492 int
+ var zb0493 bool
+ zb0492, zb0493, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0472 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0472), uint64(maxEncodedTransactionGroups))
+ if zb0492 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0492), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0473 {
+ if zb0493 {
(*z).encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0472 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0472]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0492 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0492]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0472)
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0492)
}
- for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0474 int
- var zb0475 bool
- zb0474, zb0475, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0494 int
+ var zb0495 bool
+ zb0494, zb0495, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0037)
+ err = msgp.WrapError(err, "SigProofs", zb0039)
return
}
- if zb0474 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0474), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs", zb0037)
+ if zb0494 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0494), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "SigProofs", zb0039)
return
}
- if zb0475 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037]) >= zb0474 {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037])[:zb0474]
+ if zb0495 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039]) >= zb0494 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039])[:zb0494]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] = make(certProofs, zb0474)
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] = make(certProofs, zb0494)
}
- for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] {
- bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037][zb0038].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039][zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0037, zb0038)
+ err = msgp.WrapError(err, "SigProofs", zb0039, zb0040)
return
}
}
}
case "certSbm":
{
- var zb0476 []byte
- var zb0477 int
- zb0477, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0496 []byte
+ var zb0497 int
+ zb0497, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- if zb0477 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0477), uint64(maxBitmaskSize))
+ if zb0497 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0497), uint64(maxBitmaskSize))
return
}
- zb0476, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0496, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0476)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0496)
+ }
+ case "certSH":
+ var zb0498 int
+ var zb0499 bool
+ zb0498, zb0499, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0498 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0498), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0499 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0498 {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0498]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0498)
+ }
+ for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes", zb0041)
+ return
+ }
+ }
+ case "certSHbm":
+ {
+ var zb0500 []byte
+ var zb0501 int
+ zb0501, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ if zb0501 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0501), uint64(maxBitmaskSize))
+ return
+ }
+ zb0500, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0500)
}
case "certP":
- var zb0478 int
- var zb0479 bool
- zb0478, zb0479, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0502 int
+ var zb0503 bool
+ zb0502, zb0503, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0478 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0478), uint64(maxEncodedTransactionGroups))
+ if zb0502 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0502), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0479 {
+ if zb0503 {
(*z).encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0478 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0478]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0502 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0502]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0478)
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0502)
}
- for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0480 int
- var zb0481 bool
- zb0480, zb0481, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0042 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0504 int
+ var zb0505 bool
+ zb0504, zb0505, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0039)
+ err = msgp.WrapError(err, "PartProofs", zb0042)
return
}
- if zb0480 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0480), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs", zb0039)
+ if zb0504 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0504), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "PartProofs", zb0042)
return
}
- if zb0481 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039]) >= zb0480 {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039])[:zb0480]
+ if zb0505 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042]) >= zb0504 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042])[:zb0504]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] = make(certProofs, zb0480)
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] = make(certProofs, zb0504)
}
- for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] {
- bts, err = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039][zb0040].UnmarshalMsg(bts)
+ for zb0043 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] {
+ bts, err = (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042][zb0043].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0039, zb0040)
+ err = msgp.WrapError(err, "PartProofs", zb0042, zb0043)
return
}
}
}
case "certPbm":
{
- var zb0482 []byte
- var zb0483 int
- zb0483, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0506 []byte
+ var zb0507 int
+ zb0507, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- if zb0483 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0483), uint64(maxBitmaskSize))
+ if zb0507 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0507), uint64(maxBitmaskSize))
return
}
- zb0482, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0506, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0482)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0506)
+ }
+ case "certPH":
+ var zb0508 int
+ var zb0509 bool
+ zb0508, zb0509, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0508 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0508), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0509 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0508 {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0508]
+ } else {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0508)
+ }
+ for zb0044 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0044], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes", zb0044)
+ return
+ }
+ }
+ case "certPHbm":
+ {
+ var zb0510 []byte
+ var zb0511 int
+ zb0511, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ if zb0511 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0511), uint64(maxBitmaskSize))
+ return
+ }
+ zb0510, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0510)
}
case "certr":
- var zb0484 int
- var zb0485 bool
- zb0484, zb0485, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0512 int
+ var zb0513 bool
+ zb0512, zb0513, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0484 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0484), uint64(maxEncodedTransactionGroups))
+ if zb0512 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0512), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0485 {
+ if zb0513 {
(*z).encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0484 {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0484]
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0512 {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0512]
} else {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0484)
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0512)
}
- for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0486 int
- var zb0487 bool
- zb0486, zb0487, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0045 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0514 int
+ var zb0515 bool
+ zb0514, zb0515, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0041)
+ err = msgp.WrapError(err, "Reveals", zb0045)
return
}
- if zb0486 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0486), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "Reveals", zb0041)
+ if zb0514 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0514), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "Reveals", zb0045)
return
}
- if zb0487 {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] = nil
- } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] == nil {
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] = make(revealMap, zb0486)
+ if zb0515 {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] = nil
+ } else if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] == nil {
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] = make(revealMap, zb0514)
}
- for zb0486 > 0 {
- var zb0042 uint64
- var zb0043 compactcert.Reveal
- zb0486--
- zb0042, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0514 > 0 {
+ var zb0046 uint64
+ var zb0047 compactcert.Reveal
+ zb0514--
+ zb0046, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0041)
+ err = msgp.WrapError(err, "Reveals", zb0045)
return
}
- bts, err = zb0043.UnmarshalMsg(bts)
+ bts, err = zb0047.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0041, zb0042)
+ err = msgp.WrapError(err, "Reveals", zb0045, zb0046)
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041][zb0042] = zb0043
+ (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045][zb0046] = zb0047
}
}
case "certrbm":
{
- var zb0488 []byte
- var zb0489 int
- zb0489, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0516 []byte
+ var zb0517 int
+ zb0517, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- if zb0489 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0489), uint64(maxBitmaskSize))
+ if zb0517 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0517), uint64(maxBitmaskSize))
return
}
- zb0488, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0516, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- (*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0488)
+ (*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0516)
}
default:
err = msgp.ErrNoField(string(field))
@@ -26007,104 +27464,108 @@ func (z *encodedTxns) Msgsize() (s int) {
for zb0006 := range (*z).encodedKeyregTxnFields.VoteLast {
s += (*z).encodedKeyregTxnFields.VoteLast[zb0006].Msgsize()
}
- s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation)) + 4 + msgp.BytesPrefixSize + len((*z).encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
- for zb0008 := range (*z).encodedPaymentTxnFields.Amount {
- s += (*z).encodedPaymentTxnFields.Amount[zb0008].Msgsize()
+ s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedKeyregTxnFields.BitmaskNonparticipation)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedKeyregTxnFields.HasValidRoot) * (msgp.BoolSize)) + 5 + msgp.BytesPrefixSize + len((*z).encodedKeyregTxnFields.CommitmentRoot) + 4 + msgp.BytesPrefixSize + len((*z).encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
+ for zb0009 := range (*z).encodedPaymentTxnFields.Amount {
+ s += (*z).encodedPaymentTxnFields.Amount[zb0009].Msgsize()
}
s += 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedPaymentTxnFields.BitmaskAmount)) + 6 + msgp.BytesPrefixSize + len((*z).encodedPaymentTxnFields.CloseRemainderTo) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo)) + 5 + msgp.ArrayHeaderSize
- for zb0009 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
- s += (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0009].Msgsize()
+ for zb0010 := range (*z).encodedAssetConfigTxnFields.ConfigAsset {
+ s += (*z).encodedAssetConfigTxnFields.ConfigAsset[zb0010].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset)) + 2 + msgp.ArrayHeaderSize + (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) * (msgp.Uint64Size)) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal)) + 3 + msgp.ArrayHeaderSize + (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) * (msgp.Uint32Size)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen)) + 3 + msgp.ArrayHeaderSize
- for zb0012 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0012])
+ for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0013])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName)) + 3 + msgp.ArrayHeaderSize
- for zb0013 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0013])
+ for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0014])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName)) + 3 + msgp.ArrayHeaderSize
- for zb0014 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
- s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0014])
+ for zb0015 := range (*z).encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ s += msgp.StringPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0015])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL)) + 3 + msgp.BytesPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash)) + 2 + msgp.BytesPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager)) + 2 + msgp.BytesPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve)) + 2 + msgp.BytesPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze)) + 2 + msgp.BytesPrefixSize + len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback)) + 5 + msgp.ArrayHeaderSize
- for zb0015 := range (*z).encodedAssetTransferTxnFields.XferAsset {
- s += (*z).encodedAssetTransferTxnFields.XferAsset[zb0015].Msgsize()
+ for zb0016 := range (*z).encodedAssetTransferTxnFields.XferAsset {
+ s += (*z).encodedAssetTransferTxnFields.XferAsset[zb0016].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetTransferTxnFields.BitmaskXferAsset)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedAssetTransferTxnFields.AssetAmount) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount)) + 5 + msgp.BytesPrefixSize + len((*z).encodedAssetTransferTxnFields.AssetSender) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetTransferTxnFields.BitmaskAssetSender)) + 5 + msgp.BytesPrefixSize + len((*z).encodedAssetTransferTxnFields.AssetReceiver) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver)) + 7 + msgp.BytesPrefixSize + len((*z).encodedAssetTransferTxnFields.AssetCloseTo) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo)) + 5 + msgp.BytesPrefixSize + len((*z).encodedAssetFreezeTxnFields.FreezeAccount) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount)) + 5 + msgp.ArrayHeaderSize
- for zb0017 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
- s += (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0017].Msgsize()
+ for zb0018 := range (*z).encodedAssetFreezeTxnFields.FreezeAsset {
+ s += (*z).encodedAssetFreezeTxnFields.FreezeAsset[zb0018].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen)) + 5 + msgp.ArrayHeaderSize
- for zb0018 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
- s += (*z).encodedApplicationCallTxnFields.ApplicationID[zb0018].Msgsize()
+ for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationID {
+ s += (*z).encodedApplicationCallTxnFields.ApplicationID[zb0019].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationID)) + 5 + msgp.BytesPrefixSize + len((*z).encodedApplicationCallTxnFields.OnCompletion) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion)) + 5 + msgp.ArrayHeaderSize
- for zb0019 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
+ for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs {
s += msgp.ArrayHeaderSize
- for zb0020 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019] {
- s += msgp.BytesPrefixSize + len((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0019][zb0020])
+ for zb0021 := range (*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020] {
+ s += msgp.BytesPrefixSize + len((*z).encodedApplicationCallTxnFields.ApplicationArgs[zb0020][zb0021])
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs)) + 5 + msgp.ArrayHeaderSize
- for zb0021 := range (*z).encodedApplicationCallTxnFields.Accounts {
+ for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts {
s += msgp.ArrayHeaderSize
- for zb0022 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0021] {
- s += (*z).encodedApplicationCallTxnFields.Accounts[zb0021][zb0022].Msgsize()
+ for zb0023 := range (*z).encodedApplicationCallTxnFields.Accounts[zb0022] {
+ s += (*z).encodedApplicationCallTxnFields.Accounts[zb0022][zb0023].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskAccounts)) + 5 + msgp.ArrayHeaderSize
- for zb0023 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
+ for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps {
s += msgp.ArrayHeaderSize
- for zb0024 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023] {
- s += (*z).encodedApplicationCallTxnFields.ForeignApps[zb0023][zb0024].Msgsize()
+ for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024] {
+ s += (*z).encodedApplicationCallTxnFields.ForeignApps[zb0024][zb0025].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskForeignApps)) + 5 + msgp.ArrayHeaderSize
- for zb0025 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
+ for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets {
s += msgp.ArrayHeaderSize
- for zb0026 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025] {
- s += (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0025][zb0026].Msgsize()
+ for zb0027 := range (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026] {
+ s += (*z).encodedApplicationCallTxnFields.ForeignAssets[zb0026][zb0027].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedApplicationCallTxnFields.LocalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedApplicationCallTxnFields.GlobalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice)) + 5 + msgp.ArrayHeaderSize
- for zb0031 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0031]))
+ for zb0032 := range (*z).encodedApplicationCallTxnFields.ApprovalProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.ApprovalProgram[zb0032]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram)) + 5 + msgp.ArrayHeaderSize
- for zb0032 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0032]))
+ for zb0033 := range (*z).encodedApplicationCallTxnFields.ClearStateProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.ClearStateProgram[zb0033]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedApplicationCallTxnFields.ExtraProgramPages) * (msgp.Uint32Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages)) + 8 + msgp.ArrayHeaderSize
- for zb0034 := range (*z).encodedCompactCertTxnFields.CertRound {
- s += (*z).encodedCompactCertTxnFields.CertRound[zb0034].Msgsize()
+ for zb0035 := range (*z).encodedCompactCertTxnFields.CertRound {
+ s += (*z).encodedCompactCertTxnFields.CertRound[zb0035].Msgsize()
}
s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.BitmaskCertRound)) + 9 + msgp.ArrayHeaderSize
- for zb0035 := range (*z).encodedCompactCertTxnFields.CertType {
- s += (*z).encodedCompactCertTxnFields.CertType[zb0035].Msgsize()
+ for zb0036 := range (*z).encodedCompactCertTxnFields.CertType {
+ s += (*z).encodedCompactCertTxnFields.CertType[zb0036].Msgsize()
+ }
+ s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.ArrayHeaderSize
+ for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigCommit {
+ s += (*z).encodedCompactCertTxnFields.encodedCert.SigCommit[zb0037].Msgsize()
}
- s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.BytesPrefixSize + len((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
- for zb0037 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
+ for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs {
s += msgp.ArrayHeaderSize
- for zb0038 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037] {
- s += (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0037][zb0038].Msgsize()
+ for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039] {
+ s += (*z).encodedCompactCertTxnFields.encodedCert.SigProofs[zb0039][zb0040].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0039 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0042 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs {
s += msgp.ArrayHeaderSize
- for zb0040 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039] {
- s += (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0039][zb0040].Msgsize()
+ for zb0043 := range (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042] {
+ s += (*z).encodedCompactCertTxnFields.encodedCert.PartProofs[zb0042][zb0043].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0041 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0045 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals {
s += msgp.MapHeaderSize
- if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] != nil {
- for zb0042, zb0043 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0041] {
- _ = zb0042
- _ = zb0043
- s += 0 + msgp.Uint64Size + zb0043.Msgsize()
+ if (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] != nil {
+ for zb0046, zb0047 := range (*z).encodedCompactCertTxnFields.encodedCert.Reveals[zb0045] {
+ _ = zb0046
+ _ = zb0047
+ s += 0 + msgp.Uint64Size + zb0047.Msgsize()
}
}
}
@@ -26114,7 +27575,7 @@ func (z *encodedTxns) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *encodedTxns) MsgIsZero() bool {
- return (len((*z).TxType) == 0) && (len((*z).BitmaskTxType) == 0) && ((*z).TxTypeOffset == 0) && (len((*z).encodedTxnHeaders.Sender) == 0) && (len((*z).encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedTxnHeaders.Fee) == 0) && (len((*z).encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedTxnHeaders.Note) == 0) && (len((*z).encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedTxnHeaders.Lease) == 0) && (len((*z).encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
+ return (len((*z).TxType) == 0) && (len((*z).BitmaskTxType) == 0) && ((*z).TxTypeOffset == 0) && (len((*z).encodedTxnHeaders.Sender) == 0) && (len((*z).encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedTxnHeaders.Fee) == 0) && (len((*z).encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedTxnHeaders.Note) == 0) && (len((*z).encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedTxnHeaders.Lease) == 0) && (len((*z).encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedKeyregTxnFields.HasValidRoot) == 0) && (len((*z).encodedKeyregTxnFields.CommitmentRoot) == 0) && (len((*z).encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
@@ -27360,528 +28821,552 @@ func (z *transactionBlockMessage) MsgIsZero() bool {
func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0049Len := uint32(129)
- var zb0049Mask [3]uint64 /* 144 bits */
+ zb0053Len := uint32(135)
+ var zb0053Mask [3]uint64 /* 150 bits */
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x10000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x10000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x20000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x20000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x40000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x40000000000000
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x80000000000000
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x100000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x80000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x200000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x100000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x400000000000000
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x800000000000000
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0 {
+ zb0053Len--
+ zb0053Mask[0] |= 0x1000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x200000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x2000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x400000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x4000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x800000000000000
+ zb0053Len--
+ zb0053Mask[0] |= 0x8000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x1000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x2000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x4000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0 {
- zb0049Len--
- zb0049Mask[0] |= 0x8000000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1
+ zb0053Len--
+ zb0053Mask[1] |= 0x10
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2
+ zb0053Len--
+ zb0053Mask[1] |= 0x20
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4
+ zb0053Len--
+ zb0053Mask[1] |= 0x40
}
if len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8
+ zb0053Len--
+ zb0053Mask[1] |= 0x80
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10
+ zb0053Len--
+ zb0053Mask[1] |= 0x100
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20
+ zb0053Len--
+ zb0053Mask[1] |= 0x200
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot) == 0 {
+ zb0053Len--
+ zb0053Mask[1] |= 0x400
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40
+ zb0053Len--
+ zb0053Mask[1] |= 0x800
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000
}
if len((*z).encodedSignedTxns.encodedLsigs.LogicArgs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000
}
if len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000
}
if len((*z).encodedSignedTxns.encodedLsigs.Logic) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000
}
if len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000000
}
if len((*z).encodedSignedTxns.encodedMsigs.Threshold) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000000
}
if len((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000000
}
if len((*z).encodedSignedTxns.encodedMsigs.Version) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000000
}
if len((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x10000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x20000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x40000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x80000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x100000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x10000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x200000000000000
}
if len((*z).encodedSignedTxns.AuthAddr) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x20000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x400000000000000
}
if len((*z).encodedSignedTxns.BitmaskAuthAddr) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x40000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x800000000000000
}
if len((*z).encodedSignedTxns.Sig) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x80000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x1000000000000000
}
if len((*z).encodedSignedTxns.BitmaskSig) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x100000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x2000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x200000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x4000000000000000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x400000000000000
+ zb0053Len--
+ zb0053Mask[1] |= 0x8000000000000000
}
if len((*z).encodedSignedTxns.encodedMsigs.Subsigs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x800000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x1
}
if len((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x1000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x2
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x2000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x4
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x4000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x8
}
if (*z).TransactionGroupCount == 0 {
- zb0049Len--
- zb0049Mask[1] |= 0x8000000000000000
+ zb0053Len--
+ zb0053Mask[2] |= 0x10
}
if len((*z).TransactionGroupSizes) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x1
+ zb0053Len--
+ zb0053Mask[2] |= 0x20
}
if (*z).TotalTransactionsCount == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x2
+ zb0053Len--
+ zb0053Mask[2] |= 0x40
}
if len((*z).encodedSignedTxns.encodedTxns.TxType) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x4
+ zb0053Len--
+ zb0053Mask[2] |= 0x80
}
if len((*z).encodedSignedTxns.encodedTxns.BitmaskTxType) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x8
+ zb0053Len--
+ zb0053Mask[2] |= 0x100
}
if (*z).encodedSignedTxns.encodedTxns.TxTypeOffset == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x10
+ zb0053Len--
+ zb0053Mask[2] |= 0x200
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x20
+ zb0053Len--
+ zb0053Mask[2] |= 0x400
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x40
+ zb0053Len--
+ zb0053Mask[2] |= 0x800
+ }
+ if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot) == 0 {
+ zb0053Len--
+ zb0053Mask[2] |= 0x1000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x80
+ zb0053Len--
+ zb0053Mask[2] |= 0x2000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x100
+ zb0053Len--
+ zb0053Mask[2] |= 0x4000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x200
+ zb0053Len--
+ zb0053Mask[2] |= 0x8000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x400
+ zb0053Len--
+ zb0053Mask[2] |= 0x10000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x800
+ zb0053Len--
+ zb0053Mask[2] |= 0x20000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x1000
+ zb0053Len--
+ zb0053Mask[2] |= 0x40000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x2000
+ zb0053Len--
+ zb0053Mask[2] |= 0x80000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x4000
+ zb0053Len--
+ zb0053Mask[2] |= 0x100000
}
if len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0 {
- zb0049Len--
- zb0049Mask[2] |= 0x8000
+ zb0053Len--
+ zb0053Mask[2] |= 0x200000
}
- // variable map header, size zb0049Len
- o = msgp.AppendMapHeader(o, zb0049Len)
- if zb0049Len != 0 {
- if (zb0049Mask[0] & 0x8000) == 0 { // if not empty
+ // variable map header, size zb0053Len
+ o = msgp.AppendMapHeader(o, zb0053Len)
+ if zb0053Len != 0 {
+ if (zb0053Mask[0] & 0x8000) == 0 { // if not empty
// string "aamt"
o = append(o, 0xa4, 0x61, 0x61, 0x6d, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount == nil {
@@ -27889,41 +29374,41 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount)))
}
- for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021])
+ for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022])
}
}
- if (zb0049Mask[0] & 0x10000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000) == 0 { // if not empty
// string "aamtbm"
o = append(o, 0xa6, 0x61, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
}
- if (zb0049Mask[0] & 0x20000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000) == 0 { // if not empty
// string "aclose"
o = append(o, 0xa6, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
}
- if (zb0049Mask[0] & 0x40000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000) == 0 { // if not empty
// string "aclosebm"
o = append(o, 0xa8, 0x61, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
}
- if (zb0049Mask[0] & 0x80000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000) == 0 { // if not empty
// string "afrzbm"
o = append(o, 0xa6, 0x61, 0x66, 0x72, 0x7a, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
}
- if (zb0049Mask[0] & 0x100000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000) == 0 { // if not empty
// string "am"
o = append(o, 0xa2, 0x61, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
}
- if (zb0049Mask[0] & 0x200000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000) == 0 { // if not empty
// string "ambm"
o = append(o, 0xa4, 0x61, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
}
- if (zb0049Mask[0] & 0x400000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000) == 0 { // if not empty
// string "amt"
o = append(o, 0xa3, 0x61, 0x6d, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount == nil {
@@ -27931,16 +29416,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount)))
}
- for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
- o = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0013].MarshalMsg(o)
+ for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0014].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x800000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000) == 0 { // if not empty
// string "amtbm"
o = append(o, 0xa5, 0x61, 0x6d, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
}
- if (zb0049Mask[0] & 0x1000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000) == 0 { // if not empty
// string "an"
o = append(o, 0xa2, 0x61, 0x6e)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName == nil {
@@ -27948,16 +29433,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)))
}
- for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018])
+ for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019])
}
}
- if (zb0049Mask[0] & 0x2000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000) == 0 { // if not empty
// string "anbm"
o = append(o, 0xa4, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
}
- if (zb0049Mask[0] & 0x4000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000) == 0 { // if not empty
// string "apaa"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x61)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs == nil {
@@ -27965,33 +29450,33 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)))
}
- for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] == nil {
+ for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])))
}
- for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
}
}
}
- if (zb0049Mask[0] & 0x8000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000) == 0 { // if not empty
// string "apaabm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
}
- if (zb0049Mask[0] & 0x10000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000) == 0 { // if not empty
// string "apan"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x6e)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
}
- if (zb0049Mask[0] & 0x20000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000) == 0 { // if not empty
// string "apanbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
}
- if (zb0049Mask[0] & 0x40000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000) == 0 { // if not empty
// string "apap"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x70)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram == nil {
@@ -27999,16 +29484,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)))
}
- for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
}
}
- if (zb0049Mask[0] & 0x80000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000000) == 0 { // if not empty
// string "apapbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
}
- if (zb0049Mask[0] & 0x100000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000000) == 0 { // if not empty
// string "apas"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x73)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets == nil {
@@ -28016,23 +29501,23 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)))
}
- for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] == nil {
+ for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])))
}
- for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].MarshalMsg(o)
+ for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x200000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000000) == 0 { // if not empty
// string "apasbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
}
- if (zb0049Mask[0] & 0x400000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000) == 0 { // if not empty
// string "apat"
o = append(o, 0xa4, 0x61, 0x70, 0x61, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts == nil {
@@ -28040,23 +29525,23 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts)))
}
- for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
- if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] == nil {
+ for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])))
}
- for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].MarshalMsg(o)
+ for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x800000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000000) == 0 { // if not empty
// string "apatbm"
o = append(o, 0xa6, 0x61, 0x70, 0x61, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
}
- if (zb0049Mask[0] & 0x1000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000000) == 0 { // if not empty
// string "apep"
o = append(o, 0xa4, 0x61, 0x70, 0x65, 0x70)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages == nil {
@@ -28064,16 +29549,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)))
}
- for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- o = msgp.AppendUint32(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038])
+ for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ o = msgp.AppendUint32(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039])
}
}
- if (zb0049Mask[0] & 0x2000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000000) == 0 { // if not empty
// string "apepbm"
o = append(o, 0xa6, 0x61, 0x70, 0x65, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
}
- if (zb0049Mask[0] & 0x4000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000) == 0 { // if not empty
// string "apfa"
o = append(o, 0xa4, 0x61, 0x70, 0x66, 0x61)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps == nil {
@@ -28081,23 +29566,23 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps)))
}
- for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] == nil {
+ for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])))
}
- for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].MarshalMsg(o)
+ for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x8000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000) == 0 { // if not empty
// string "apfabm"
o = append(o, 0xa6, 0x61, 0x70, 0x66, 0x61, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
}
- if (zb0049Mask[0] & 0x10000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000000) == 0 { // if not empty
// string "apid"
o = append(o, 0xa4, 0x61, 0x70, 0x69, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID == nil {
@@ -28105,16 +29590,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID)))
}
- for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].MarshalMsg(o)
+ for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x20000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000000) == 0 { // if not empty
// string "apidbm"
o = append(o, 0xa6, 0x61, 0x70, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
}
- if (zb0049Mask[0] & 0x40000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000000) == 0 { // if not empty
// string "apsu"
o = append(o, 0xa4, 0x61, 0x70, 0x73, 0x75)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram == nil {
@@ -28122,36 +29607,36 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)))
}
- for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
- o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
}
}
- if (zb0049Mask[0] & 0x80000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000000000) == 0 { // if not empty
// string "apsubm"
o = append(o, 0xa6, 0x61, 0x70, 0x73, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
}
- if (zb0049Mask[0] & 0x100000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x100000000000) == 0 { // if not empty
// string "arcv"
o = append(o, 0xa4, 0x61, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
}
- if (zb0049Mask[0] & 0x200000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x200000000000) == 0 { // if not empty
// string "arcvbm"
o = append(o, 0xa6, 0x61, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
}
- if (zb0049Mask[0] & 0x400000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000000) == 0 { // if not empty
// string "asnd"
o = append(o, 0xa4, 0x61, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender)
}
- if (zb0049Mask[0] & 0x800000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000000000) == 0 { // if not empty
// string "asndbm"
o = append(o, 0xa6, 0x61, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
}
- if (zb0049Mask[0] & 0x1000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x1000000000000) == 0 { // if not empty
// string "au"
o = append(o, 0xa2, 0x61, 0x75)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL == nil {
@@ -28159,21 +29644,21 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)))
}
- for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019])
+ for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020])
}
}
- if (zb0049Mask[0] & 0x2000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x2000000000000) == 0 { // if not empty
// string "aubm"
o = append(o, 0xa4, 0x61, 0x75, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
}
- if (zb0049Mask[0] & 0x4000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000000) == 0 { // if not empty
// string "c"
o = append(o, 0xa1, 0x63)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
}
- if (zb0049Mask[0] & 0x8000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000000) == 0 { // if not empty
// string "caid"
o = append(o, 0xa4, 0x63, 0x61, 0x69, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset == nil {
@@ -28181,21 +29666,21 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)))
}
- for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- o = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].MarshalMsg(o)
+ for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x10000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x10000000000000) == 0 { // if not empty
// string "caidbm"
o = append(o, 0xa6, 0x63, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
}
- if (zb0049Mask[0] & 0x20000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x20000000000000) == 0 { // if not empty
// string "cbm"
o = append(o, 0xa3, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
}
- if (zb0049Mask[0] & 0x40000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x40000000000000) == 0 { // if not empty
// string "certP"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x50)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs == nil {
@@ -28203,23 +29688,40 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)))
}
- for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] == nil {
+ for zb0047 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])))
}
- for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].MarshalMsg(o)
+ for zb0048 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x80000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x80000000000000) == 0 { // if not empty
+ // string "certPH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48)
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)))
+ }
+ for zb0049 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049])
+ }
+ }
+ if (zb0053Mask[0] & 0x100000000000000) == 0 { // if not empty
+ // string "certPHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x50, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ }
+ if (zb0053Mask[0] & 0x200000000000000) == 0 { // if not empty
// string "certPbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x50, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
}
- if (zb0049Mask[0] & 0x100000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x400000000000000) == 0 { // if not empty
// string "certS"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x53)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs == nil {
@@ -28227,33 +29729,57 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)))
}
- for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] == nil {
+ for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])))
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])))
}
- for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].MarshalMsg(o)
+ for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x200000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x800000000000000) == 0 { // if not empty
+ // string "certSH"
+ o = append(o, 0xa6, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48)
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)))
+ }
+ for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046])
+ }
+ }
+ if (zb0053Mask[0] & 0x1000000000000000) == 0 { // if not empty
+ // string "certSHbm"
+ o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x53, 0x48, 0x62, 0x6d)
+ o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ }
+ if (zb0053Mask[0] & 0x2000000000000000) == 0 { // if not empty
// string "certSbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x53, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
}
- if (zb0049Mask[0] & 0x400000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x4000000000000000) == 0 { // if not empty
// string "certc"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x63)
- o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)))
+ }
+ for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].MarshalMsg(o)
+ }
}
- if (zb0049Mask[0] & 0x800000000000000) == 0 { // if not empty
+ if (zb0053Mask[0] & 0x8000000000000000) == 0 { // if not empty
// string "certcbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
}
- if (zb0049Mask[0] & 0x1000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1) == 0 { // if not empty
// string "certr"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x72)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals == nil {
@@ -28261,31 +29787,31 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)))
}
- for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
+ for zb0050 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
o = msgp.AppendNil(o)
} else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046])))
+ o = msgp.AppendMapHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050])))
}
- zb0047_keys := make([]uint64, 0, len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046]))
- for zb0047 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] {
- zb0047_keys = append(zb0047_keys, zb0047)
+ zb0051_keys := make([]uint64, 0, len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050]))
+ for zb0051 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] {
+ zb0051_keys = append(zb0051_keys, zb0051)
}
- sort.Sort(SortUint64(zb0047_keys))
- for _, zb0047 := range zb0047_keys {
- zb0048 := (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047]
- _ = zb0048
- o = msgp.AppendUint64(o, zb0047)
- o = zb0048.MarshalMsg(o)
+ sort.Sort(SortUint64(zb0051_keys))
+ for _, zb0051 := range zb0051_keys {
+ zb0052 := (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051]
+ _ = zb0052
+ o = msgp.AppendUint64(o, zb0051)
+ o = zb0052.MarshalMsg(o)
}
}
}
- if (zb0049Mask[0] & 0x2000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2) == 0 { // if not empty
// string "certrbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
}
- if (zb0049Mask[0] & 0x4000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4) == 0 { // if not empty
// string "certrnd"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound == nil {
@@ -28293,16 +29819,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound)))
}
- for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
- o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].MarshalMsg(o)
+ for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].MarshalMsg(o)
}
}
- if (zb0049Mask[0] & 0x8000000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8) == 0 { // if not empty
// string "certrndbm"
o = append(o, 0xa9, 0x63, 0x65, 0x72, 0x74, 0x72, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
}
- if (zb0049Mask[1] & 0x1) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10) == 0 { // if not empty
// string "certtype"
o = append(o, 0xa8, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType == nil {
@@ -28310,16 +29836,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType)))
}
- for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
- o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].MarshalMsg(o)
+ for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x2) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20) == 0 { // if not empty
// string "certtypebm"
o = append(o, 0xaa, 0x63, 0x65, 0x72, 0x74, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
}
- if (zb0049Mask[1] & 0x4) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40) == 0 { // if not empty
// string "certw"
o = append(o, 0xa5, 0x63, 0x65, 0x72, 0x74, 0x77)
if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight == nil {
@@ -28327,26 +29853,31 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)))
}
- for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041])
+ for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043])
}
}
- if (zb0049Mask[1] & 0x8) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80) == 0 { // if not empty
// string "certwbm"
o = append(o, 0xa7, 0x63, 0x65, 0x72, 0x74, 0x77, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
}
- if (zb0049Mask[1] & 0x10) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100) == 0 { // if not empty
// string "close"
o = append(o, 0xa5, 0x63, 0x6c, 0x6f, 0x73, 0x65)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
}
- if (zb0049Mask[1] & 0x20) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200) == 0 { // if not empty
// string "closebm"
o = append(o, 0xa7, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
}
- if (zb0049Mask[1] & 0x40) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400) == 0 { // if not empty
+ // string "comt"
+ o = append(o, 0xa4, 0x63, 0x6f, 0x6d, 0x74)
+ o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ }
+ if (zb0053Mask[1] & 0x800) == 0 { // if not empty
// string "dc"
o = append(o, 0xa2, 0x64, 0x63)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals == nil {
@@ -28354,36 +29885,36 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)))
}
- for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- o = msgp.AppendUint32(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016])
+ for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ o = msgp.AppendUint32(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017])
}
}
- if (zb0049Mask[1] & 0x80) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000) == 0 { // if not empty
// string "dcbm"
o = append(o, 0xa4, 0x64, 0x63, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
}
- if (zb0049Mask[1] & 0x100) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000) == 0 { // if not empty
// string "dfbm"
o = append(o, 0xa4, 0x64, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
}
- if (zb0049Mask[1] & 0x200) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000) == 0 { // if not empty
// string "f"
o = append(o, 0xa1, 0x66)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
}
- if (zb0049Mask[1] & 0x400) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000) == 0 { // if not empty
// string "fadd"
o = append(o, 0xa4, 0x66, 0x61, 0x64, 0x64)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
}
- if (zb0049Mask[1] & 0x800) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000) == 0 { // if not empty
// string "faddbm"
o = append(o, 0xa6, 0x66, 0x61, 0x64, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
}
- if (zb0049Mask[1] & 0x1000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000) == 0 { // if not empty
// string "faid"
o = append(o, 0xa4, 0x66, 0x61, 0x69, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset == nil {
@@ -28391,21 +29922,21 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)))
}
- for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- o = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].MarshalMsg(o)
+ for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x2000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000) == 0 { // if not empty
// string "faidbm"
o = append(o, 0xa6, 0x66, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
}
- if (zb0049Mask[1] & 0x4000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000) == 0 { // if not empty
// string "fbm"
o = append(o, 0xa3, 0x66, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
}
- if (zb0049Mask[1] & 0x8000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000) == 0 { // if not empty
// string "fee"
o = append(o, 0xa3, 0x66, 0x65, 0x65)
if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee == nil {
@@ -28417,12 +29948,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee[zb0006].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x10000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000) == 0 { // if not empty
// string "feebm"
o = append(o, 0xa5, 0x66, 0x65, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee))
}
- if (zb0049Mask[1] & 0x20000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000) == 0 { // if not empty
// string "fv"
o = append(o, 0xa2, 0x66, 0x76)
if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid == nil {
@@ -28434,17 +29965,17 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid[zb0007].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x40000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000) == 0 { // if not empty
// string "fvbm"
o = append(o, 0xa4, 0x66, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
}
- if (zb0049Mask[1] & 0x80000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000) == 0 { // if not empty
// string "genbm"
o = append(o, 0xa5, 0x67, 0x65, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
}
- if (zb0049Mask[1] & 0x100000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000) == 0 { // if not empty
// string "gnbs"
o = append(o, 0xa4, 0x67, 0x6e, 0x62, 0x73)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice == nil {
@@ -28452,16 +29983,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)))
}
- for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035])
+ for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036])
}
}
- if (zb0049Mask[1] & 0x200000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000) == 0 { // if not empty
// string "gnbsbm"
o = append(o, 0xa6, 0x67, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
}
- if (zb0049Mask[1] & 0x400000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000) == 0 { // if not empty
// string "gnui"
o = append(o, 0xa4, 0x67, 0x6e, 0x75, 0x69)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint == nil {
@@ -28469,21 +30000,21 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)))
}
- for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034])
+ for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035])
}
}
- if (zb0049Mask[1] & 0x800000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000) == 0 { // if not empty
// string "gnuibm"
o = append(o, 0xa6, 0x67, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
}
- if (zb0049Mask[1] & 0x1000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000) == 0 { // if not empty
// string "grpbm"
o = append(o, 0xa5, 0x67, 0x72, 0x70, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup))
}
- if (zb0049Mask[1] & 0x2000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000) == 0 { // if not empty
// string "lnbs"
o = append(o, 0xa4, 0x6c, 0x6e, 0x62, 0x73)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice == nil {
@@ -28491,16 +30022,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)))
}
- for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033])
+ for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034])
}
}
- if (zb0049Mask[1] & 0x4000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000) == 0 { // if not empty
// string "lnbsbm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x62, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
}
- if (zb0049Mask[1] & 0x8000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000) == 0 { // if not empty
// string "lnui"
o = append(o, 0xa4, 0x6c, 0x6e, 0x75, 0x69)
if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint == nil {
@@ -28508,16 +30039,16 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)))
}
- for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032])
+ for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033])
}
}
- if (zb0049Mask[1] & 0x10000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000) == 0 { // if not empty
// string "lnuibm"
o = append(o, 0xa6, 0x6c, 0x6e, 0x75, 0x69, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
}
- if (zb0049Mask[1] & 0x20000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000) == 0 { // if not empty
// string "lsigarg"
o = append(o, 0xa7, 0x6c, 0x73, 0x69, 0x67, 0x61, 0x72, 0x67)
if (*z).encodedSignedTxns.encodedLsigs.LogicArgs == nil {
@@ -28536,12 +30067,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
}
}
}
- if (zb0049Mask[1] & 0x40000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000) == 0 { // if not empty
// string "lsigargbm"
o = append(o, 0xa9, 0x6c, 0x73, 0x69, 0x67, 0x61, 0x72, 0x67, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs))
}
- if (zb0049Mask[1] & 0x80000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000) == 0 { // if not empty
// string "lsigl"
o = append(o, 0xa5, 0x6c, 0x73, 0x69, 0x67, 0x6c)
if (*z).encodedSignedTxns.encodedLsigs.Logic == nil {
@@ -28553,12 +30084,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedLsigs.Logic[zb0003])
}
}
- if (zb0049Mask[1] & 0x100000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000) == 0 { // if not empty
// string "lsiglbm"
o = append(o, 0xa7, 0x6c, 0x73, 0x69, 0x67, 0x6c, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic))
}
- if (zb0049Mask[1] & 0x200000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000) == 0 { // if not empty
// string "lv"
o = append(o, 0xa2, 0x6c, 0x76)
if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid == nil {
@@ -28570,57 +30101,57 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid[zb0008].MarshalMsg(o)
}
}
- if (zb0049Mask[1] & 0x400000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000) == 0 { // if not empty
// string "lvbm"
o = append(o, 0xa4, 0x6c, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid))
}
- if (zb0049Mask[1] & 0x800000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000000) == 0 { // if not empty
// string "lx"
o = append(o, 0xa2, 0x6c, 0x78)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease)
}
- if (zb0049Mask[1] & 0x1000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000000) == 0 { // if not empty
// string "lxbm"
o = append(o, 0xa4, 0x6c, 0x78, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease))
}
- if (zb0049Mask[1] & 0x2000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000000) == 0 { // if not empty
// string "m"
o = append(o, 0xa1, 0x6d)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
}
- if (zb0049Mask[1] & 0x4000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000000) == 0 { // if not empty
// string "mbm"
o = append(o, 0xa3, 0x6d, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
}
- if (zb0049Mask[1] & 0x8000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000000) == 0 { // if not empty
// string "msigthr"
o = append(o, 0xa7, 0x6d, 0x73, 0x69, 0x67, 0x74, 0x68, 0x72)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedMsigs.Threshold)
}
- if (zb0049Mask[1] & 0x10000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000000) == 0 { // if not empty
// string "msigthrbm"
o = append(o, 0xa9, 0x6d, 0x73, 0x69, 0x67, 0x74, 0x68, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold))
}
- if (zb0049Mask[1] & 0x20000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000000) == 0 { // if not empty
// string "msigv"
o = append(o, 0xa5, 0x6d, 0x73, 0x69, 0x67, 0x76)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedMsigs.Version)
}
- if (zb0049Mask[1] & 0x40000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000000) == 0 { // if not empty
// string "msigvbm"
o = append(o, 0xa7, 0x6d, 0x73, 0x69, 0x67, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion))
}
- if (zb0049Mask[1] & 0x80000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000000) == 0 { // if not empty
// string "nonpartbm"
o = append(o, 0xa9, 0x6e, 0x6f, 0x6e, 0x70, 0x61, 0x72, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
}
- if (zb0049Mask[1] & 0x100000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000000) == 0 { // if not empty
// string "note"
o = append(o, 0xa4, 0x6e, 0x6f, 0x74, 0x65)
if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note == nil {
@@ -28632,77 +30163,77 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note[zb0009])
}
}
- if (zb0049Mask[1] & 0x200000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000000) == 0 { // if not empty
// string "notebm"
o = append(o, 0xa6, 0x6e, 0x6f, 0x74, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote))
}
- if (zb0049Mask[1] & 0x400000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000000) == 0 { // if not empty
// string "r"
o = append(o, 0xa1, 0x72)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
}
- if (zb0049Mask[1] & 0x800000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x10000000000000) == 0 { // if not empty
// string "rbm"
o = append(o, 0xa3, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
}
- if (zb0049Mask[1] & 0x1000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x20000000000000) == 0 { // if not empty
// string "rcv"
o = append(o, 0xa3, 0x72, 0x63, 0x76)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver)
}
- if (zb0049Mask[1] & 0x2000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x40000000000000) == 0 { // if not empty
// string "rcvbm"
o = append(o, 0xa5, 0x72, 0x63, 0x76, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
}
- if (zb0049Mask[1] & 0x4000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x80000000000000) == 0 { // if not empty
// string "rekey"
o = append(o, 0xa5, 0x72, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo)
}
- if (zb0049Mask[1] & 0x8000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x100000000000000) == 0 { // if not empty
// string "rekeybm"
o = append(o, 0xa7, 0x72, 0x65, 0x6b, 0x65, 0x79, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
}
- if (zb0049Mask[1] & 0x10000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x200000000000000) == 0 { // if not empty
// string "selkey"
o = append(o, 0xa6, 0x73, 0x65, 0x6c, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK)
}
- if (zb0049Mask[1] & 0x20000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x400000000000000) == 0 { // if not empty
// string "sgnr"
o = append(o, 0xa4, 0x73, 0x67, 0x6e, 0x72)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.AuthAddr)
}
- if (zb0049Mask[1] & 0x40000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x800000000000000) == 0 { // if not empty
// string "sgnrbm"
o = append(o, 0xa6, 0x73, 0x67, 0x6e, 0x72, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.BitmaskAuthAddr))
}
- if (zb0049Mask[1] & 0x80000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x1000000000000000) == 0 { // if not empty
// string "sig"
o = append(o, 0xa3, 0x73, 0x69, 0x67)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.Sig)
}
- if (zb0049Mask[1] & 0x100000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x2000000000000000) == 0 { // if not empty
// string "sigbm"
o = append(o, 0xa5, 0x73, 0x69, 0x67, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.BitmaskSig))
}
- if (zb0049Mask[1] & 0x200000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x4000000000000000) == 0 { // if not empty
// string "snd"
o = append(o, 0xa3, 0x73, 0x6e, 0x64)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender)
}
- if (zb0049Mask[1] & 0x400000000000000) == 0 { // if not empty
+ if (zb0053Mask[1] & 0x8000000000000000) == 0 { // if not empty
// string "sndbm"
o = append(o, 0xa5, 0x73, 0x6e, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender))
}
- if (zb0049Mask[1] & 0x800000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x1) == 0 { // if not empty
// string "subsig"
o = append(o, 0xa6, 0x73, 0x75, 0x62, 0x73, 0x69, 0x67)
if (*z).encodedSignedTxns.encodedMsigs.Subsigs == nil {
@@ -28721,12 +30252,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
}
}
}
- if (zb0049Mask[1] & 0x1000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x2) == 0 { // if not empty
// string "subsigsbm"
o = append(o, 0xa9, 0x73, 0x75, 0x62, 0x73, 0x69, 0x67, 0x73, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs))
}
- if (zb0049Mask[1] & 0x2000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x4) == 0 { // if not empty
// string "t"
o = append(o, 0xa1, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total == nil {
@@ -28734,46 +30265,46 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)))
}
- for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015])
+ for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016])
}
}
- if (zb0049Mask[1] & 0x4000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x8) == 0 { // if not empty
// string "tbm"
o = append(o, 0xa3, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
}
- if (zb0049Mask[1] & 0x8000000000000000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x10) == 0 { // if not empty
// string "tgc"
o = append(o, 0xa3, 0x74, 0x67, 0x63)
o = msgp.AppendUint64(o, (*z).TransactionGroupCount)
}
- if (zb0049Mask[2] & 0x1) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x20) == 0 { // if not empty
// string "tgs"
o = append(o, 0xa3, 0x74, 0x67, 0x73)
o = msgp.AppendBytes(o, (*z).TransactionGroupSizes)
}
- if (zb0049Mask[2] & 0x2) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x40) == 0 { // if not empty
// string "ttc"
o = append(o, 0xa3, 0x74, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).TotalTransactionsCount)
}
- if (zb0049Mask[2] & 0x4) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x80) == 0 { // if not empty
// string "type"
o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.TxType)
}
- if (zb0049Mask[2] & 0x8) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x100) == 0 { // if not empty
// string "typebm"
o = append(o, 0xa6, 0x74, 0x79, 0x70, 0x65, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.BitmaskTxType))
}
- if (zb0049Mask[2] & 0x10) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x200) == 0 { // if not empty
// string "typeo"
o = append(o, 0xa5, 0x74, 0x79, 0x70, 0x65, 0x6f)
o = msgp.AppendByte(o, (*z).encodedSignedTxns.encodedTxns.TxTypeOffset)
}
- if (zb0049Mask[2] & 0x20) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x400) == 0 { // if not empty
// string "un"
o = append(o, 0xa2, 0x75, 0x6e)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName == nil {
@@ -28781,16 +30312,28 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)))
}
- for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017])
+ for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ o = msgp.AppendString(o, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018])
}
}
- if (zb0049Mask[2] & 0x40) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x800) == 0 { // if not empty
// string "unbm"
o = append(o, 0xa4, 0x75, 0x6e, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
}
- if (zb0049Mask[2] & 0x80) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x1000) == 0 { // if not empty
+ // string "vldrt"
+ o = append(o, 0xa5, 0x76, 0x6c, 0x64, 0x72, 0x74)
+ if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot == nil {
+ o = msgp.AppendNil(o)
+ } else {
+ o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot)))
+ }
+ for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ o = msgp.AppendBool(o, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013])
+ }
+ }
+ if (zb0053Mask[2] & 0x2000) == 0 { // if not empty
// string "votefst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst == nil {
@@ -28802,17 +30345,17 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x100) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x4000) == 0 { // if not empty
// string "votefstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x66, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
}
- if (zb0049Mask[2] & 0x200) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x8000) == 0 { // if not empty
// string "votekbm"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
}
- if (zb0049Mask[2] & 0x400) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x10000) == 0 { // if not empty
// string "votekd"
o = append(o, 0xa6, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution == nil {
@@ -28824,12 +30367,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012])
}
}
- if (zb0049Mask[2] & 0x800) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x20000) == 0 { // if not empty
// string "votekey"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6b, 0x65, 0x79)
o = msgp.AppendBytes(o, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK)
}
- if (zb0049Mask[2] & 0x1000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x40000) == 0 { // if not empty
// string "votelst"
o = append(o, 0xa7, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74)
if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast == nil {
@@ -28841,12 +30384,12 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
o = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x2000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x80000) == 0 { // if not empty
// string "votelstbm"
o = append(o, 0xa9, 0x76, 0x6f, 0x74, 0x65, 0x6c, 0x73, 0x74, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
}
- if (zb0049Mask[2] & 0x4000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x100000) == 0 { // if not empty
// string "xaid"
o = append(o, 0xa4, 0x78, 0x61, 0x69, 0x64)
if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset == nil {
@@ -28854,11 +30397,11 @@ func (z *txGroupsEncodingStub) MarshalMsg(b []byte) (o []byte) {
} else {
o = msgp.AppendArrayHeader(o, uint32(len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset)))
}
- for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- o = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].MarshalMsg(o)
+ for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ o = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].MarshalMsg(o)
}
}
- if (zb0049Mask[2] & 0x8000) == 0 { // if not empty
+ if (zb0053Mask[2] & 0x200000) == 0 { // if not empty
// string "xaidbm"
o = append(o, 0xa6, 0x78, 0x61, 0x69, 0x64, 0x62, 0x6d)
o = msgp.AppendBytes(o, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
@@ -28876,41 +30419,41 @@ func (_ *txGroupsEncodingStub) CanMarshalMsg(z interface{}) bool {
func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zb0049 int
- var zb0050 bool
- zb0049, zb0050, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0053 int
+ var zb0054 bool
+ zb0053, zb0054, bts, err = msgp.ReadMapHeaderBytes(bts)
if _, ok := err.(msgp.TypeError); ok {
- zb0049, zb0050, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ zb0053, zb0054, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err)
return
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
(*z).TotalTransactionsCount, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TotalTransactionsCount")
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
(*z).TransactionGroupCount, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TransactionGroupCount")
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0051 int
- zb0051, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0055 int
+ zb0055, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TransactionGroupSizes")
return
}
- if zb0051 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0051), uint64(maxEncodedTransactionGroups))
+ if zb0055 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0055), uint64(maxEncodedTransactionGroups))
return
}
(*z).TransactionGroupSizes, bts, err = msgp.ReadBytesBytes(bts, (*z).TransactionGroupSizes)
@@ -28919,16 +30462,16 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0052 int
- zb0052, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0056 int
+ zb0056, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Sig")
return
}
- if zb0052 > maxSignatureBytes {
- err = msgp.ErrOverflow(uint64(zb0052), uint64(maxSignatureBytes))
+ if zb0056 > maxSignatureBytes {
+ err = msgp.ErrOverflow(uint64(zb0056), uint64(maxSignatureBytes))
return
}
(*z).encodedSignedTxns.Sig, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.Sig)
@@ -28937,38 +30480,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0053 []byte
- var zb0054 int
- zb0054, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0057 []byte
+ var zb0058 int
+ zb0058, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSig")
return
}
- if zb0054 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0054), uint64(maxBitmaskSize))
+ if zb0058 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0058), uint64(maxBitmaskSize))
return
}
- zb0053, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskSig))
+ zb0057, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskSig))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSig")
return
}
- (*z).encodedSignedTxns.BitmaskSig = bitmask(zb0053)
+ (*z).encodedSignedTxns.BitmaskSig = bitmask(zb0057)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0055 int
- zb0055, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0059 int
+ zb0059, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Version")
return
}
- if zb0055 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0055), uint64(maxEncodedTransactionGroups))
+ if zb0059 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0059), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedMsigs.Version, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedMsigs.Version)
@@ -28977,38 +30520,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0056 []byte
- var zb0057 int
- zb0057, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0060 []byte
+ var zb0061 int
+ zb0061, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVersion")
return
}
- if zb0057 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0057), uint64(maxBitmaskSize))
+ if zb0061 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0061), uint64(maxBitmaskSize))
return
}
- zb0056, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion))
+ zb0060, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVersion")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskVersion = bitmask(zb0056)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskVersion = bitmask(zb0060)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0058 int
- zb0058, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0062 int
+ zb0062, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Threshold")
return
}
- if zb0058 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0058), uint64(maxEncodedTransactionGroups))
+ if zb0062 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0062), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedMsigs.Threshold, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedMsigs.Threshold)
@@ -29017,68 +30560,68 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0059 []byte
- var zb0060 int
- zb0060, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0063 []byte
+ var zb0064 int
+ zb0064, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskThreshold")
return
}
- if zb0060 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0060), uint64(maxBitmaskSize))
+ if zb0064 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0064), uint64(maxBitmaskSize))
return
}
- zb0059, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold))
+ zb0063, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskThreshold")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold = bitmask(zb0059)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold = bitmask(zb0063)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0061 int
- var zb0062 bool
- zb0061, zb0062, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0065 int
+ var zb0066 bool
+ zb0065, zb0066, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Subsigs")
return
}
- if zb0061 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0061), uint64(maxEncodedTransactionGroups))
+ if zb0065 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0065), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Subsigs")
return
}
- if zb0062 {
+ if zb0066 {
(*z).encodedSignedTxns.encodedMsigs.Subsigs = nil
- } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs) >= zb0061 {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs = ((*z).encodedSignedTxns.encodedMsigs.Subsigs)[:zb0061]
+ } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs) >= zb0065 {
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs = ((*z).encodedSignedTxns.encodedMsigs.Subsigs)[:zb0065]
} else {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0061)
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0065)
}
for zb0001 := range (*z).encodedSignedTxns.encodedMsigs.Subsigs {
- var zb0063 int
- var zb0064 bool
- zb0063, zb0064, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0067 int
+ var zb0068 bool
+ zb0067, zb0068, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Subsigs", zb0001)
return
}
- if zb0063 > crypto.MaxMultisig {
- err = msgp.ErrOverflow(uint64(zb0063), uint64(crypto.MaxMultisig))
+ if zb0067 > crypto.MaxMultisig {
+ err = msgp.ErrOverflow(uint64(zb0067), uint64(crypto.MaxMultisig))
err = msgp.WrapError(err, "struct-from-array", "Subsigs", zb0001)
return
}
- if zb0064 {
+ if zb0068 {
(*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = nil
- } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001]) >= zb0063 {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = ((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001])[:zb0063]
+ } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001]) >= zb0067 {
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = ((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001])[:zb0067]
} else {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0063)
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0067)
}
for zb0002 := range (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] {
bts, err = (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001][zb0002].UnmarshalMsg(bts)
@@ -29089,58 +30632,58 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0065 []byte
- var zb0066 int
- zb0066, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0069 []byte
+ var zb0070 int
+ zb0070, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSubsigs")
return
}
- if zb0066 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0066), uint64(maxBitmaskSize))
+ if zb0070 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0070), uint64(maxBitmaskSize))
return
}
- zb0065, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs))
+ zb0069, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSubsigs")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs = bitmask(zb0065)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs = bitmask(zb0069)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0067 int
- var zb0068 bool
- zb0067, zb0068, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0071 int
+ var zb0072 bool
+ zb0071, zb0072, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Logic")
return
}
- if zb0067 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0067), uint64(maxEncodedTransactionGroups))
+ if zb0071 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0071), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Logic")
return
}
- if zb0068 {
+ if zb0072 {
(*z).encodedSignedTxns.encodedLsigs.Logic = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.Logic != nil && cap((*z).encodedSignedTxns.encodedLsigs.Logic) >= zb0067 {
- (*z).encodedSignedTxns.encodedLsigs.Logic = ((*z).encodedSignedTxns.encodedLsigs.Logic)[:zb0067]
+ } else if (*z).encodedSignedTxns.encodedLsigs.Logic != nil && cap((*z).encodedSignedTxns.encodedLsigs.Logic) >= zb0071 {
+ (*z).encodedSignedTxns.encodedLsigs.Logic = ((*z).encodedSignedTxns.encodedLsigs.Logic)[:zb0071]
} else {
- (*z).encodedSignedTxns.encodedLsigs.Logic = make([][]byte, zb0067)
+ (*z).encodedSignedTxns.encodedLsigs.Logic = make([][]byte, zb0071)
}
for zb0003 := range (*z).encodedSignedTxns.encodedLsigs.Logic {
- var zb0069 int
- zb0069, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0073 int
+ zb0073, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Logic", zb0003)
return
}
- if zb0069 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0069), uint64(config.MaxLogicSigMaxSize))
+ if zb0073 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0073), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedSignedTxns.encodedLsigs.Logic[zb0003], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedLsigs.Logic[zb0003])
@@ -29150,78 +30693,78 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0070 []byte
- var zb0071 int
- zb0071, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0074 []byte
+ var zb0075 int
+ zb0075, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogic")
return
}
- if zb0071 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0071), uint64(maxBitmaskSize))
+ if zb0075 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0075), uint64(maxBitmaskSize))
return
}
- zb0070, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic))
+ zb0074, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogic")
return
}
- (*z).encodedSignedTxns.encodedLsigs.BitmaskLogic = bitmask(zb0070)
+ (*z).encodedSignedTxns.encodedLsigs.BitmaskLogic = bitmask(zb0074)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0072 int
- var zb0073 bool
- zb0072, zb0073, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0076 int
+ var zb0077 bool
+ zb0076, zb0077, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs")
return
}
- if zb0072 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0072), uint64(maxEncodedTransactionGroups))
+ if zb0076 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0076), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LogicArgs")
return
}
- if zb0073 {
+ if zb0077 {
(*z).encodedSignedTxns.encodedLsigs.LogicArgs = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs) >= zb0072 {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs)[:zb0072]
+ } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs) >= zb0076 {
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs)[:zb0076]
} else {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs = make([][][]byte, zb0072)
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs = make([][][]byte, zb0076)
}
for zb0004 := range (*z).encodedSignedTxns.encodedLsigs.LogicArgs {
- var zb0074 int
- var zb0075 bool
- zb0074, zb0075, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0078 int
+ var zb0079 bool
+ zb0078, zb0079, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004)
return
}
- if zb0074 > transactions.EvalMaxArgs {
- err = msgp.ErrOverflow(uint64(zb0074), uint64(transactions.EvalMaxArgs))
+ if zb0078 > transactions.EvalMaxArgs {
+ err = msgp.ErrOverflow(uint64(zb0078), uint64(transactions.EvalMaxArgs))
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004)
return
}
- if zb0075 {
+ if zb0079 {
(*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004]) >= zb0074 {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004])[:zb0074]
+ } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004]) >= zb0078 {
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004])[:zb0078]
} else {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0074)
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0078)
}
for zb0005 := range (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] {
- var zb0076 int
- zb0076, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0080 int
+ zb0080, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LogicArgs", zb0004, zb0005)
return
}
- if zb0076 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0076), uint64(config.MaxLogicSigMaxSize))
+ if zb0080 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0080), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004][zb0005], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004][zb0005])
@@ -29232,38 +30775,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0077 []byte
- var zb0078 int
- zb0078, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0081 []byte
+ var zb0082 int
+ zb0082, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogicArgs")
return
}
- if zb0078 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0078), uint64(maxBitmaskSize))
+ if zb0082 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0082), uint64(maxBitmaskSize))
return
}
- zb0077, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs))
+ zb0081, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLogicArgs")
return
}
- (*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs = bitmask(zb0077)
+ (*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs = bitmask(zb0081)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0079 int
- zb0079, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0083 int
+ zb0083, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AuthAddr")
return
}
- if zb0079 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0079), uint64(maxAddressBytes))
+ if zb0083 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0083), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.AuthAddr, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.AuthAddr)
@@ -29272,38 +30815,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0080 []byte
- var zb0081 int
- zb0081, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0084 []byte
+ var zb0085 int
+ zb0085, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAuthAddr")
return
}
- if zb0081 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0081), uint64(maxBitmaskSize))
+ if zb0085 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0085), uint64(maxBitmaskSize))
return
}
- zb0080, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskAuthAddr))
+ zb0084, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskAuthAddr))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAuthAddr")
return
}
- (*z).encodedSignedTxns.BitmaskAuthAddr = bitmask(zb0080)
+ (*z).encodedSignedTxns.BitmaskAuthAddr = bitmask(zb0084)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0082 int
- zb0082, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0086 int
+ zb0086, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxType")
return
}
- if zb0082 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0082), uint64(maxEncodedTransactionGroups))
+ if zb0086 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0086), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedTxns.TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.TxType)
@@ -29312,46 +30855,46 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0083 []byte
- var zb0084 int
- zb0084, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0087 []byte
+ var zb0088 int
+ zb0088, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- if zb0084 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0084), uint64(maxBitmaskSize))
+ if zb0088 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0088), uint64(maxBitmaskSize))
return
}
- zb0083, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.BitmaskTxType))
+ zb0087, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTxType")
return
}
- (*z).encodedSignedTxns.encodedTxns.BitmaskTxType = bitmask(zb0083)
+ (*z).encodedSignedTxns.encodedTxns.BitmaskTxType = bitmask(zb0087)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
(*z).encodedSignedTxns.encodedTxns.TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "TxTypeOffset")
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0085 int
- zb0085, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0089 int
+ zb0089, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Sender")
return
}
- if zb0085 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0085), uint64(maxAddressBytes))
+ if zb0089 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0089), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender)
@@ -29360,48 +30903,48 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0086 []byte
- var zb0087 int
- zb0087, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0090 []byte
+ var zb0091 int
+ zb0091, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- if zb0087 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0087), uint64(maxBitmaskSize))
+ if zb0091 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0091), uint64(maxBitmaskSize))
return
}
- zb0086, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender))
+ zb0090, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSender")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0086)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0090)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0088 int
- var zb0089 bool
- zb0088, zb0089, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0092 int
+ var zb0093 bool
+ zb0092, zb0093, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0088 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0088), uint64(maxEncodedTransactionGroups))
+ if zb0092 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0092), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Fee")
return
}
- if zb0089 {
+ if zb0093 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) >= zb0088 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee)[:zb0088]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) >= zb0092 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee)[:zb0092]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0088)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0092)
}
for zb0006 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee[zb0006].UnmarshalMsg(bts)
@@ -29411,48 +30954,48 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0090 []byte
- var zb0091 int
- zb0091, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0094 []byte
+ var zb0095 int
+ zb0095, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- if zb0091 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0091), uint64(maxBitmaskSize))
+ if zb0095 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0095), uint64(maxBitmaskSize))
return
}
- zb0090, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee))
+ zb0094, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFee")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0090)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0094)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0092 int
- var zb0093 bool
- zb0092, zb0093, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0096 int
+ var zb0097 bool
+ zb0096, zb0097, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0092 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0092), uint64(maxEncodedTransactionGroups))
+ if zb0096 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0096), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FirstValid")
return
}
- if zb0093 {
+ if zb0097 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) >= zb0092 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid)[:zb0092]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) >= zb0096 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid)[:zb0096]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0092)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0096)
}
for zb0007 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid[zb0007].UnmarshalMsg(bts)
@@ -29462,48 +31005,48 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0094 []byte
- var zb0095 int
- zb0095, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0098 []byte
+ var zb0099 int
+ zb0099, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- if zb0095 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0095), uint64(maxBitmaskSize))
+ if zb0099 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0099), uint64(maxBitmaskSize))
return
}
- zb0094, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
+ zb0098, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFirstValid")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0094)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0098)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0096 int
- var zb0097 bool
- zb0096, zb0097, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0100 int
+ var zb0101 bool
+ zb0100, zb0101, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0096 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0096), uint64(maxEncodedTransactionGroups))
+ if zb0100 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0100), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LastValid")
return
}
- if zb0097 {
+ if zb0101 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) >= zb0096 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid)[:zb0096]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) >= zb0100 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid)[:zb0100]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0096)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0100)
}
for zb0008 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid[zb0008].UnmarshalMsg(bts)
@@ -29513,58 +31056,58 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0098 []byte
- var zb0099 int
- zb0099, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0102 []byte
+ var zb0103 int
+ zb0103, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- if zb0099 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0099), uint64(maxBitmaskSize))
+ if zb0103 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0103), uint64(maxBitmaskSize))
return
}
- zb0098, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid))
+ zb0102, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLastValid")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0098)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0102)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0100 int
- var zb0101 bool
- zb0100, zb0101, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0104 int
+ var zb0105 bool
+ zb0104, zb0105, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0100 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0100), uint64(maxEncodedTransactionGroups))
+ if zb0104 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0104), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Note")
return
}
- if zb0101 {
+ if zb0105 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) >= zb0100 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note)[:zb0100]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) >= zb0104 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note)[:zb0104]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0100)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0104)
}
for zb0009 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note {
- var zb0102 int
- zb0102, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0106 int
+ zb0106, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Note", zb0009)
return
}
- if zb0102 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0102), uint64(config.MaxTxnNoteBytes))
+ if zb0106 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0106), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note[zb0009], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note[zb0009])
@@ -29574,82 +31117,82 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0103 []byte
- var zb0104 int
- zb0104, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0107 []byte
+ var zb0108 int
+ zb0108, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- if zb0104 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0104), uint64(maxBitmaskSize))
+ if zb0108 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0108), uint64(maxBitmaskSize))
return
}
- zb0103, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote))
+ zb0107, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNote")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0103)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0107)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0105 []byte
- var zb0106 int
- zb0106, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0109 []byte
+ var zb0110 int
+ zb0110, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- if zb0106 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0106), uint64(maxBitmaskSize))
+ if zb0110 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0110), uint64(maxBitmaskSize))
return
}
- zb0105, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
+ zb0109, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGenesisID")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0105)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0109)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0107 []byte
- var zb0108 int
- zb0108, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0111 []byte
+ var zb0112 int
+ zb0112, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- if zb0108 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0108), uint64(maxBitmaskSize))
+ if zb0112 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0112), uint64(maxBitmaskSize))
return
}
- zb0107, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup))
+ zb0111, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGroup")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0107)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0111)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0109 int
- zb0109, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0113 int
+ zb0113, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Lease")
return
}
- if zb0109 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0109), uint64(maxAddressBytes))
+ if zb0113 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0113), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease)
@@ -29658,38 +31201,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0110 []byte
- var zb0111 int
- zb0111, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0114 []byte
+ var zb0115 int
+ zb0115, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- if zb0111 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0111), uint64(maxBitmaskSize))
+ if zb0115 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0115), uint64(maxBitmaskSize))
return
}
- zb0110, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease))
+ zb0114, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLease")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0110)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0114)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0112 int
- zb0112, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0116 int
+ zb0116, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "RekeyTo")
return
}
- if zb0112 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0112), uint64(maxAddressBytes))
+ if zb0116 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0116), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo)
@@ -29698,38 +31241,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0113 []byte
- var zb0114 int
- zb0114, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0117 []byte
+ var zb0118 int
+ zb0118, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- if zb0114 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0114), uint64(maxBitmaskSize))
+ if zb0118 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0118), uint64(maxBitmaskSize))
return
}
- zb0113, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
+ zb0117, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskRekeyTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0113)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0117)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0115 int
- zb0115, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0119 int
+ zb0119, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VotePK")
return
}
- if zb0115 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0115), uint64(maxAddressBytes))
+ if zb0119 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0119), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK)
@@ -29738,16 +31281,16 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0116 int
- zb0116, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0120 int
+ zb0120, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SelectionPK")
return
}
- if zb0116 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0116), uint64(maxAddressBytes))
+ if zb0120 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0120), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK)
@@ -29756,26 +31299,26 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0117 int
- var zb0118 bool
- zb0117, zb0118, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0121 int
+ var zb0122 bool
+ zb0121, zb0122, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0117 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0117), uint64(maxEncodedTransactionGroups))
+ if zb0121 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0121), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteFirst")
return
}
- if zb0118 {
+ if zb0122 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0117 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0117]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0121 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0121]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0117)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0121)
}
for zb0010 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].UnmarshalMsg(bts)
@@ -29785,48 +31328,48 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0119 []byte
- var zb0120 int
- zb0120, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0123 []byte
+ var zb0124 int
+ zb0124, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- if zb0120 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0120), uint64(maxBitmaskSize))
+ if zb0124 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0124), uint64(maxBitmaskSize))
return
}
- zb0119, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0123, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteFirst")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0119)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0123)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0121 int
- var zb0122 bool
- zb0121, zb0122, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0125 int
+ var zb0126 bool
+ zb0125, zb0126, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0121 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0121), uint64(maxEncodedTransactionGroups))
+ if zb0125 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0125), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteLast")
return
}
- if zb0122 {
+ if zb0126 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0121 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0121]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0125 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0125]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0121)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0125)
}
for zb0011 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].UnmarshalMsg(bts)
@@ -29836,48 +31379,48 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0123 []byte
- var zb0124 int
- zb0124, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0127 []byte
+ var zb0128 int
+ zb0128, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- if zb0124 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0124), uint64(maxBitmaskSize))
+ if zb0128 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0128), uint64(maxBitmaskSize))
return
}
- zb0123, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0127, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskVoteLast")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0123)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0127)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0125 int
- var zb0126 bool
- zb0125, zb0126, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0129 int
+ var zb0130 bool
+ zb0129, zb0130, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0125 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0125), uint64(maxEncodedTransactionGroups))
+ if zb0129 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0129), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
return
}
- if zb0126 {
+ if zb0130 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0125 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0125]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0129 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0129]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0125)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0129)
}
for zb0012 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012], bts, err = msgp.ReadUint64Bytes(bts)
@@ -29887,60 +31430,107 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0127 []byte
- var zb0128 int
- zb0128, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0131 []byte
+ var zb0132 int
+ zb0132, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- if zb0128 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0128), uint64(maxBitmaskSize))
+ if zb0132 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0132), uint64(maxBitmaskSize))
return
}
- zb0127, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
+ zb0131, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskKeys")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0127)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0131)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0129 []byte
- var zb0130 int
- zb0130, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0133 []byte
+ var zb0134 int
+ zb0134, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- if zb0130 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0130), uint64(maxBitmaskSize))
+ if zb0134 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0134), uint64(maxBitmaskSize))
return
}
- zb0129, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0133, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskNonparticipation")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0129)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0133)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0131 int
- zb0131, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0135 int
+ var zb0136 bool
+ zb0135, zb0136, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0135 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0135), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot")
+ return
+ }
+ if zb0136 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot) >= zb0135 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot)[:zb0135]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0135)
+ }
+ for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "HasValidRoot", zb0013)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0137 int
+ zb0137, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ if zb0137 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0137), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "CommitmentRoot")
+ return
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0138 int
+ zb0138, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Receiver")
return
}
- if zb0131 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0131), uint64(maxAddressBytes))
+ if zb0138 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0138), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver)
@@ -29949,89 +31539,89 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0132 []byte
- var zb0133 int
- zb0133, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0139 []byte
+ var zb0140 int
+ zb0140, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- if zb0133 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0133), uint64(maxBitmaskSize))
+ if zb0140 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0140), uint64(maxBitmaskSize))
return
}
- zb0132, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
+ zb0139, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReceiver")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0132)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0139)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0134 int
- var zb0135 bool
- zb0134, zb0135, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0141 int
+ var zb0142 bool
+ zb0141, zb0142, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0134 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0134), uint64(maxEncodedTransactionGroups))
+ if zb0141 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0141), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Amount")
return
}
- if zb0135 {
+ if zb0142 {
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) >= zb0134 {
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount)[:zb0134]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) >= zb0141 {
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount)[:zb0141]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0134)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0141)
}
- for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0013].UnmarshalMsg(bts)
+ for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0014].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Amount", zb0013)
+ err = msgp.WrapError(err, "struct-from-array", "Amount", zb0014)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0136 []byte
- var zb0137 int
- zb0137, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0143 []byte
+ var zb0144 int
+ zb0144, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- if zb0137 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0137), uint64(maxBitmaskSize))
+ if zb0144 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0144), uint64(maxBitmaskSize))
return
}
- zb0136, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
+ zb0143, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAmount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0136)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0143)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0138 int
- zb0138, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0145 int
+ zb0145, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CloseRemainderTo")
return
}
- if zb0138 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0138), uint64(maxAddressBytes))
+ if zb0145 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0145), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
@@ -30040,366 +31630,366 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0139 []byte
- var zb0140 int
- zb0140, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0146 []byte
+ var zb0147 int
+ zb0147, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- if zb0140 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0140), uint64(maxBitmaskSize))
+ if zb0147 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0147), uint64(maxBitmaskSize))
return
}
- zb0139, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0146, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCloseRemainderTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0139)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0146)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0141 int
- var zb0142 bool
- zb0141, zb0142, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0148 int
+ var zb0149 bool
+ zb0148, zb0149, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0141 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0141), uint64(maxEncodedTransactionGroups))
+ if zb0148 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0148), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ConfigAsset")
return
}
- if zb0142 {
+ if zb0149 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0141 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0141]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0148 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0148]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0141)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0148)
}
- for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].UnmarshalMsg(bts)
+ for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0014)
+ err = msgp.WrapError(err, "struct-from-array", "ConfigAsset", zb0015)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0143 []byte
- var zb0144 int
- zb0144, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0150 []byte
+ var zb0151 int
+ zb0151, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- if zb0144 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0144), uint64(maxBitmaskSize))
+ if zb0151 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0151), uint64(maxBitmaskSize))
return
}
- zb0143, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0150, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskConfigAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0143)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0150)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0145 int
- var zb0146 bool
- zb0145, zb0146, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0152 int
+ var zb0153 bool
+ zb0152, zb0153, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0145 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0145), uint64(maxEncodedTransactionGroups))
+ if zb0152 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0152), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Total")
return
}
- if zb0146 {
+ if zb0153 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0145 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0145]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0152 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0152]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0145)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0152)
}
- for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Total", zb0015)
+ err = msgp.WrapError(err, "struct-from-array", "Total", zb0016)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0147 []byte
- var zb0148 int
- zb0148, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0154 []byte
+ var zb0155 int
+ zb0155, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- if zb0148 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0148), uint64(maxBitmaskSize))
+ if zb0155 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0155), uint64(maxBitmaskSize))
return
}
- zb0147, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0154, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskTotal")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0147)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0154)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0149 int
- var zb0150 bool
- zb0149, zb0150, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0156 int
+ var zb0157 bool
+ zb0156, zb0157, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0149 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0149), uint64(maxEncodedTransactionGroups))
+ if zb0156 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0156), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Decimals")
return
}
- if zb0150 {
+ if zb0157 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0149 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0149]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0156 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0156]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0149)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0156)
}
- for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0016)
+ err = msgp.WrapError(err, "struct-from-array", "Decimals", zb0017)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0151 []byte
- var zb0152 int
- zb0152, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0158 []byte
+ var zb0159 int
+ zb0159, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- if zb0152 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0152), uint64(maxBitmaskSize))
+ if zb0159 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0159), uint64(maxBitmaskSize))
return
}
- zb0151, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0158, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDecimals")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0151)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0158)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0153 []byte
- var zb0154 int
- zb0154, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0160 []byte
+ var zb0161 int
+ zb0161, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- if zb0154 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0154), uint64(maxBitmaskSize))
+ if zb0161 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0161), uint64(maxBitmaskSize))
return
}
- zb0153, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0160, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskDefaultFrozen")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0153)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0160)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0155 int
- var zb0156 bool
- zb0155, zb0156, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0162 int
+ var zb0163 bool
+ zb0162, zb0163, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0155 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0155), uint64(maxEncodedTransactionGroups))
+ if zb0162 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0162), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "UnitName")
return
}
- if zb0156 {
+ if zb0163 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0155 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0155]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0162 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0162]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0155)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0162)
}
- for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017], bts, err = msgp.ReadStringBytes(bts)
+ for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0017)
+ err = msgp.WrapError(err, "struct-from-array", "UnitName", zb0018)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0157 []byte
- var zb0158 int
- zb0158, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0164 []byte
+ var zb0165 int
+ zb0165, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- if zb0158 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0158), uint64(maxBitmaskSize))
+ if zb0165 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0165), uint64(maxBitmaskSize))
return
}
- zb0157, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0164, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskUnitName")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0157)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0164)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0159 int
- var zb0160 bool
- zb0159, zb0160, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0166 int
+ var zb0167 bool
+ zb0166, zb0167, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0159 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0159), uint64(maxEncodedTransactionGroups))
+ if zb0166 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0166), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetName")
return
}
- if zb0160 {
+ if zb0167 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0159 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0159]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0166 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0166]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0159)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0166)
}
- for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018], bts, err = msgp.ReadStringBytes(bts)
+ for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0018)
+ err = msgp.WrapError(err, "struct-from-array", "AssetName", zb0019)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0161 []byte
- var zb0162 int
- zb0162, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0168 []byte
+ var zb0169 int
+ zb0169, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- if zb0162 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0162), uint64(maxBitmaskSize))
+ if zb0169 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0169), uint64(maxBitmaskSize))
return
}
- zb0161, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0168, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetName")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0161)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0168)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0163 int
- var zb0164 bool
- zb0163, zb0164, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0170 int
+ var zb0171 bool
+ zb0170, zb0171, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0163 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0163), uint64(maxEncodedTransactionGroups))
+ if zb0170 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0170), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "URL")
return
}
- if zb0164 {
+ if zb0171 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0163 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0163]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0170 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0170]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0163)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0170)
}
- for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019], bts, err = msgp.ReadStringBytes(bts)
+ for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "URL", zb0019)
+ err = msgp.WrapError(err, "struct-from-array", "URL", zb0020)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0165 []byte
- var zb0166 int
- zb0166, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0172 []byte
+ var zb0173 int
+ zb0173, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- if zb0166 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0166), uint64(maxBitmaskSize))
+ if zb0173 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0173), uint64(maxBitmaskSize))
return
}
- zb0165, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0172, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskURL")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0165)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0172)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0167 int
- zb0167, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0174 int
+ zb0174, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "MetadataHash")
return
}
- if zb0167 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0167), uint64(maxAddressBytes))
+ if zb0174 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0174), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -30408,38 +31998,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0168 []byte
- var zb0169 int
- zb0169, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0175 []byte
+ var zb0176 int
+ zb0176, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- if zb0169 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0169), uint64(maxBitmaskSize))
+ if zb0176 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0176), uint64(maxBitmaskSize))
return
}
- zb0168, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0175, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskMetadataHash")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0168)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0175)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0170 int
- zb0170, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0177 int
+ zb0177, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Manager")
return
}
- if zb0170 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0170), uint64(maxAddressBytes))
+ if zb0177 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0177), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -30448,38 +32038,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0171 []byte
- var zb0172 int
- zb0172, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0178 []byte
+ var zb0179 int
+ zb0179, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- if zb0172 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0172), uint64(maxBitmaskSize))
+ if zb0179 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0179), uint64(maxBitmaskSize))
return
}
- zb0171, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0178, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskManager")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0171)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0178)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0173 int
- zb0173, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0180 int
+ zb0180, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reserve")
return
}
- if zb0173 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0173), uint64(maxAddressBytes))
+ if zb0180 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0180), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -30488,38 +32078,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0174 []byte
- var zb0175 int
- zb0175, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0181 []byte
+ var zb0182 int
+ zb0182, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- if zb0175 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0175), uint64(maxBitmaskSize))
+ if zb0182 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0182), uint64(maxBitmaskSize))
return
}
- zb0174, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0181, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReserve")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0174)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0181)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0176 int
- zb0176, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0183 int
+ zb0183, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Freeze")
return
}
- if zb0176 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0176), uint64(maxAddressBytes))
+ if zb0183 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0183), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -30528,38 +32118,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0177 []byte
- var zb0178 int
- zb0178, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0184 []byte
+ var zb0185 int
+ zb0185, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- if zb0178 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0178), uint64(maxBitmaskSize))
+ if zb0185 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0185), uint64(maxBitmaskSize))
return
}
- zb0177, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0184, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreeze")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0177)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0184)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0179 int
- zb0179, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0186 int
+ zb0186, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Clawback")
return
}
- if zb0179 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0179), uint64(maxAddressBytes))
+ if zb0186 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0186), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -30568,140 +32158,140 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0180 []byte
- var zb0181 int
- zb0181, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0187 []byte
+ var zb0188 int
+ zb0188, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- if zb0181 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0181), uint64(maxBitmaskSize))
+ if zb0188 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0188), uint64(maxBitmaskSize))
return
}
- zb0180, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0187, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClawback")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0180)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0187)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0182 int
- var zb0183 bool
- zb0182, zb0183, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0189 int
+ var zb0190 bool
+ zb0189, zb0190, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0182 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0182), uint64(maxEncodedTransactionGroups))
+ if zb0189 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0189), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "XferAsset")
return
}
- if zb0183 {
+ if zb0190 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0182 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0182]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0189 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0189]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0182)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0189)
}
- for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].UnmarshalMsg(bts)
+ for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0020)
+ err = msgp.WrapError(err, "struct-from-array", "XferAsset", zb0021)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0184 []byte
- var zb0185 int
- zb0185, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0191 []byte
+ var zb0192 int
+ zb0192, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- if zb0185 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0185), uint64(maxBitmaskSize))
+ if zb0192 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0192), uint64(maxBitmaskSize))
return
}
- zb0184, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0191, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskXferAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0184)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0191)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0186 int
- var zb0187 bool
- zb0186, zb0187, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0193 int
+ var zb0194 bool
+ zb0193, zb0194, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0186 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0186), uint64(maxEncodedTransactionGroups))
+ if zb0193 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0193), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "AssetAmount")
return
}
- if zb0187 {
+ if zb0194 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0186 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0186]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0193 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0193]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0186)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0193)
}
- for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0021)
+ err = msgp.WrapError(err, "struct-from-array", "AssetAmount", zb0022)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0188 []byte
- var zb0189 int
- zb0189, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0195 []byte
+ var zb0196 int
+ zb0196, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- if zb0189 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0189), uint64(maxBitmaskSize))
+ if zb0196 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0196), uint64(maxBitmaskSize))
return
}
- zb0188, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0195, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetAmount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0188)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0195)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0190 int
- zb0190, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0197 int
+ zb0197, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetSender")
return
}
- if zb0190 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0190), uint64(maxAddressBytes))
+ if zb0197 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0197), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender)
@@ -30710,38 +32300,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0191 []byte
- var zb0192 int
- zb0192, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0198 []byte
+ var zb0199 int
+ zb0199, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- if zb0192 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0192), uint64(maxBitmaskSize))
+ if zb0199 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0199), uint64(maxBitmaskSize))
return
}
- zb0191, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0198, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetSender")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0191)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0198)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0193 int
- zb0193, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0200 int
+ zb0200, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetReceiver")
return
}
- if zb0193 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0193), uint64(maxAddressBytes))
+ if zb0200 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0200), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
@@ -30750,38 +32340,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0194 []byte
- var zb0195 int
- zb0195, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0201 []byte
+ var zb0202 int
+ zb0202, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- if zb0195 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0195), uint64(maxBitmaskSize))
+ if zb0202 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0202), uint64(maxBitmaskSize))
return
}
- zb0194, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0201, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetReceiver")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0194)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0201)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0196 int
- zb0196, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0203 int
+ zb0203, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "AssetCloseTo")
return
}
- if zb0196 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0196), uint64(maxAddressBytes))
+ if zb0203 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0203), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
@@ -30790,38 +32380,38 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0197 []byte
- var zb0198 int
- zb0198, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0204 []byte
+ var zb0205 int
+ zb0205, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- if zb0198 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0198), uint64(maxBitmaskSize))
+ if zb0205 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0205), uint64(maxBitmaskSize))
return
}
- zb0197, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0204, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetCloseTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0197)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0204)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0199 int
- zb0199, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0206 int
+ zb0206, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAccount")
return
}
- if zb0199 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0199), uint64(maxAddressBytes))
+ if zb0206 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0206), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
@@ -30830,162 +32420,162 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0200 []byte
- var zb0201 int
- zb0201, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0207 []byte
+ var zb0208 int
+ zb0208, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- if zb0201 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0201), uint64(maxBitmaskSize))
+ if zb0208 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0208), uint64(maxBitmaskSize))
return
}
- zb0200, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0207, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAccount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0200)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0207)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0202 int
- var zb0203 bool
- zb0202, zb0203, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0209 int
+ var zb0210 bool
+ zb0209, zb0210, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0202 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0202), uint64(maxEncodedTransactionGroups))
+ if zb0209 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0209), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "FreezeAsset")
return
}
- if zb0203 {
+ if zb0210 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0202 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0202]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0209 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0209]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0202)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0209)
}
- for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0022)
+ err = msgp.WrapError(err, "struct-from-array", "FreezeAsset", zb0023)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0204 []byte
- var zb0205 int
- zb0205, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0211 []byte
+ var zb0212 int
+ zb0212, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- if zb0205 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0205), uint64(maxBitmaskSize))
+ if zb0212 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0212), uint64(maxBitmaskSize))
return
}
- zb0204, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0211, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskFreezeAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0204)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0211)
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0206 []byte
- var zb0207 int
- zb0207, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0213 []byte
+ var zb0214 int
+ zb0214, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- if zb0207 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0207), uint64(maxBitmaskSize))
+ if zb0214 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0214), uint64(maxBitmaskSize))
return
}
- zb0206, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0213, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAssetFrozen")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0206)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0213)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0208 int
- var zb0209 bool
- zb0208, zb0209, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0215 int
+ var zb0216 bool
+ zb0215, zb0216, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0208 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0208), uint64(maxEncodedTransactionGroups))
+ if zb0215 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0215), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationID")
return
}
- if zb0209 {
+ if zb0216 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0208 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0208]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0215 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0215]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0208)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0215)
}
- for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].UnmarshalMsg(bts)
+ for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0023)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationID", zb0024)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0210 []byte
- var zb0211 int
- zb0211, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0217 []byte
+ var zb0218 int
+ zb0218, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- if zb0211 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0211), uint64(maxBitmaskSize))
+ if zb0218 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0218), uint64(maxBitmaskSize))
return
}
- zb0210, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0217, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationID")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0210)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0217)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0212 int
- zb0212, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0219 int
+ zb0219, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "OnCompletion")
return
}
- if zb0212 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0212), uint64(maxEncodedTransactionGroups))
+ if zb0219 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0219), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
@@ -30994,1119 +32584,1232 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0213 []byte
- var zb0214 int
- zb0214, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0220 []byte
+ var zb0221 int
+ zb0221, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- if zb0214 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0214), uint64(maxBitmaskSize))
+ if zb0221 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0221), uint64(maxBitmaskSize))
return
}
- zb0213, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0220, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskOnCompletion")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0213)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0220)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0215 int
- var zb0216 bool
- zb0215, zb0216, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0222 int
+ var zb0223 bool
+ zb0222, zb0223, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0215 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0215), uint64(maxEncodedTransactionGroups))
+ if zb0222 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0222), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs")
return
}
- if zb0216 {
+ if zb0223 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0215 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0215]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0222 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0222]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0215)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0222)
}
- for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0217 int
- var zb0218 bool
- zb0217, zb0218, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0224 int
+ var zb0225 bool
+ zb0224, zb0225, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025)
return
}
- if zb0217 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0217), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024)
+ if zb0224 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0224), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025)
return
}
- if zb0218 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024]) >= zb0217 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])[:zb0217]
+ if zb0225 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025]) >= zb0224 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])[:zb0224]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = make(applicationArgs, zb0217)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = make(applicationArgs, zb0224)
}
- for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0024, zb0025)
+ err = msgp.WrapError(err, "struct-from-array", "ApplicationArgs", zb0025, zb0026)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0219 []byte
- var zb0220 int
- zb0220, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0226 []byte
+ var zb0227 int
+ zb0227, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- if zb0220 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0220), uint64(maxBitmaskSize))
+ if zb0227 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0227), uint64(maxBitmaskSize))
return
}
- zb0219, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0226, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApplicationArgs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0219)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0226)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0221 int
- var zb0222 bool
- zb0221, zb0222, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0228 int
+ var zb0229 bool
+ zb0228, zb0229, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0221 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0221), uint64(maxEncodedTransactionGroups))
+ if zb0228 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0228), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Accounts")
return
}
- if zb0222 {
+ if zb0229 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0221 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0221]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0228 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0228]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0221)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0228)
}
- for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
- var zb0223 int
- var zb0224 bool
- zb0223, zb0224, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ var zb0230 int
+ var zb0231 bool
+ zb0230, zb0231, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027)
return
}
- if zb0223 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0223), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026)
+ if zb0230 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0230), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027)
return
}
- if zb0224 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026]) >= zb0223 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])[:zb0223]
+ if zb0231 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027]) >= zb0230 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])[:zb0230]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = make(addresses, zb0223)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = make(addresses, zb0230)
}
- for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].UnmarshalMsg(bts)
+ for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0026, zb0027)
+ err = msgp.WrapError(err, "struct-from-array", "Accounts", zb0027, zb0028)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0225 []byte
- var zb0226 int
- zb0226, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0232 []byte
+ var zb0233 int
+ zb0233, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- if zb0226 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0226), uint64(maxBitmaskSize))
+ if zb0233 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0233), uint64(maxBitmaskSize))
return
}
- zb0225, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0232, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskAccounts")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0225)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0232)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0227 int
- var zb0228 bool
- zb0227, zb0228, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0234 int
+ var zb0235 bool
+ zb0234, zb0235, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0227 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0227), uint64(maxEncodedTransactionGroups))
+ if zb0234 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0234), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignApps")
return
}
- if zb0228 {
+ if zb0235 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0227 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0227]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0234 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0234]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0227)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0234)
}
- for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- var zb0229 int
- var zb0230 bool
- zb0229, zb0230, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ var zb0236 int
+ var zb0237 bool
+ zb0236, zb0237, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029)
return
}
- if zb0229 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0229), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028)
+ if zb0236 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0236), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029)
return
}
- if zb0230 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028]) >= zb0229 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])[:zb0229]
+ if zb0237 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029]) >= zb0236 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])[:zb0236]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = make(appIndices, zb0229)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = make(appIndices, zb0236)
}
- for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].UnmarshalMsg(bts)
+ for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0028, zb0029)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignApps", zb0029, zb0030)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0231 []byte
- var zb0232 int
- zb0232, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0238 []byte
+ var zb0239 int
+ zb0239, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- if zb0232 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0232), uint64(maxBitmaskSize))
+ if zb0239 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0239), uint64(maxBitmaskSize))
return
}
- zb0231, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0238, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignApps")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0231)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0238)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0233 int
- var zb0234 bool
- zb0233, zb0234, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0240 int
+ var zb0241 bool
+ zb0240, zb0241, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0233 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0233), uint64(maxEncodedTransactionGroups))
+ if zb0240 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0240), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ForeignAssets")
return
}
- if zb0234 {
+ if zb0241 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0233 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0233]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0240 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0240]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0233)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0240)
}
- for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- var zb0235 int
- var zb0236 bool
- zb0235, zb0236, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0242 int
+ var zb0243 bool
+ zb0242, zb0243, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031)
return
}
- if zb0235 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0235), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030)
+ if zb0242 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0242), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031)
return
}
- if zb0236 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030]) >= zb0235 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])[:zb0235]
+ if zb0243 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031]) >= zb0242 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])[:zb0242]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = make(assetIndices, zb0235)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = make(assetIndices, zb0242)
}
- for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].UnmarshalMsg(bts)
+ for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0030, zb0031)
+ err = msgp.WrapError(err, "struct-from-array", "ForeignAssets", zb0031, zb0032)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0237 []byte
- var zb0238 int
- zb0238, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0244 []byte
+ var zb0245 int
+ zb0245, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- if zb0238 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0238), uint64(maxBitmaskSize))
+ if zb0245 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0245), uint64(maxBitmaskSize))
return
}
- zb0237, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0244, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskForeignAssets")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0237)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0244)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0239 int
- var zb0240 bool
- zb0239, zb0240, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0246 int
+ var zb0247 bool
+ zb0246, zb0247, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0239 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0239), uint64(maxEncodedTransactionGroups))
+ if zb0246 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0246), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumUint")
return
}
- if zb0240 {
+ if zb0247 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0239 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0239]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0246 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0246]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0239)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0246)
}
- for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0032)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumUint", zb0033)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0241 []byte
- var zb0242 int
- zb0242, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0248 []byte
+ var zb0249 int
+ zb0249, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- if zb0242 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0242), uint64(maxBitmaskSize))
+ if zb0249 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0249), uint64(maxBitmaskSize))
return
}
- zb0241, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0248, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumUint")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0241)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0248)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0243 int
- var zb0244 bool
- zb0243, zb0244, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0250 int
+ var zb0251 bool
+ zb0250, zb0251, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0243 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0243), uint64(maxEncodedTransactionGroups))
+ if zb0250 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0250), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice")
return
}
- if zb0244 {
+ if zb0251 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0243 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0243]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0250 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0250]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0243)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0250)
}
- for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0033)
+ err = msgp.WrapError(err, "struct-from-array", "LocalNumByteSlice", zb0034)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0245 []byte
- var zb0246 int
- zb0246, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0252 []byte
+ var zb0253 int
+ zb0253, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- if zb0246 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0246), uint64(maxBitmaskSize))
+ if zb0253 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0253), uint64(maxBitmaskSize))
return
}
- zb0245, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0252, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0245)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0252)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0247 int
- var zb0248 bool
- zb0247, zb0248, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0254 int
+ var zb0255 bool
+ zb0254, zb0255, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0247 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0247), uint64(maxEncodedTransactionGroups))
+ if zb0254 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0254), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint")
return
}
- if zb0248 {
+ if zb0255 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0247 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0247]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0254 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0254]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0247)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0254)
}
- for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0034)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumUint", zb0035)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0249 []byte
- var zb0250 int
- zb0250, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0256 []byte
+ var zb0257 int
+ zb0257, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- if zb0250 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0250), uint64(maxBitmaskSize))
+ if zb0257 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0257), uint64(maxBitmaskSize))
return
}
- zb0249, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0256, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumUint")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0249)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0256)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0251 int
- var zb0252 bool
- zb0251, zb0252, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0258 int
+ var zb0259 bool
+ zb0258, zb0259, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0251 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0251), uint64(maxEncodedTransactionGroups))
+ if zb0258 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0258), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice")
return
}
- if zb0252 {
+ if zb0259 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0251 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0251]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0258 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0258]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0251)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0258)
}
- for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0035)
+ err = msgp.WrapError(err, "struct-from-array", "GlobalNumByteSlice", zb0036)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0253 []byte
- var zb0254 int
- zb0254, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0260 []byte
+ var zb0261 int
+ zb0261, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- if zb0254 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0254), uint64(maxBitmaskSize))
+ if zb0261 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0261), uint64(maxBitmaskSize))
return
}
- zb0253, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0260, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0253)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0260)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0255 int
- var zb0256 bool
- zb0255, zb0256, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0262 int
+ var zb0263 bool
+ zb0262, zb0263, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0255 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0255), uint64(maxEncodedTransactionGroups))
+ if zb0262 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0262), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
return
}
- if zb0256 {
+ if zb0263 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0255 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0255]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0262 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0262]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0255)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0262)
}
- for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0257 []byte
- var zb0258 int
- zb0258, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0264 []byte
+ var zb0265 int
+ zb0265, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0037)
return
}
- if zb0258 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0258), uint64(config.MaxAvailableAppProgramLen))
+ if zb0265 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0265), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0257, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ zb0264, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram", zb0037)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036] = program(zb0257)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037] = program(zb0264)
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0259 []byte
- var zb0260 int
- zb0260, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0266 []byte
+ var zb0267 int
+ zb0267, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- if zb0260 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0260), uint64(maxBitmaskSize))
+ if zb0267 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0267), uint64(maxBitmaskSize))
return
}
- zb0259, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0266, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskApprovalProgram")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0259)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0266)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0261 int
- var zb0262 bool
- zb0261, zb0262, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0268 int
+ var zb0269 bool
+ zb0268, zb0269, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0261 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0261), uint64(maxEncodedTransactionGroups))
+ if zb0268 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0268), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
return
}
- if zb0262 {
+ if zb0269 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0261 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0261]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0268 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0268]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0261)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0268)
}
- for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0263 []byte
- var zb0264 int
- zb0264, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0270 []byte
+ var zb0271 int
+ zb0271, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0038)
return
}
- if zb0264 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0264), uint64(config.MaxAvailableAppProgramLen))
+ if zb0271 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0271), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0263, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ zb0270, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram", zb0038)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037] = program(zb0263)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038] = program(zb0270)
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0265 []byte
- var zb0266 int
- zb0266, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0272 []byte
+ var zb0273 int
+ zb0273, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- if zb0266 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0266), uint64(maxBitmaskSize))
+ if zb0273 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0273), uint64(maxBitmaskSize))
return
}
- zb0265, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0272, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskClearStateProgram")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0265)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0272)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0267 int
- var zb0268 bool
- zb0267, zb0268, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0274 int
+ var zb0275 bool
+ zb0274, zb0275, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0267 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0267), uint64(maxEncodedTransactionGroups))
+ if zb0274 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0274), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
return
}
- if zb0268 {
+ if zb0275 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0267 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0267]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0274 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0274]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0267)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0274)
}
- for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0038)
+ err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages", zb0039)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0269 []byte
- var zb0270 int
- zb0270, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0276 []byte
+ var zb0277 int
+ zb0277, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- if zb0270 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0270), uint64(maxBitmaskSize))
+ if zb0277 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0277), uint64(maxBitmaskSize))
return
}
- zb0269, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0276, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskExtraProgramPages")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0269)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0276)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0271 int
- var zb0272 bool
- zb0271, zb0272, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0278 int
+ var zb0279 bool
+ zb0278, zb0279, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0271 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0271), uint64(maxEncodedTransactionGroups))
+ if zb0278 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0278), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertRound")
return
}
- if zb0272 {
+ if zb0279 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0271 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0271]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0278 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0278]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0271)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0278)
}
- for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0039)
+ err = msgp.WrapError(err, "struct-from-array", "CertRound", zb0040)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0273 []byte
- var zb0274 int
- zb0274, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0280 []byte
+ var zb0281 int
+ zb0281, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- if zb0274 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0274), uint64(maxBitmaskSize))
+ if zb0281 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0281), uint64(maxBitmaskSize))
return
}
- zb0273, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0280, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertRound")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0273)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0280)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0275 int
- var zb0276 bool
- zb0275, zb0276, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0282 int
+ var zb0283 bool
+ zb0282, zb0283, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0275 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0275), uint64(maxEncodedTransactionGroups))
+ if zb0282 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0282), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "CertType")
return
}
- if zb0276 {
+ if zb0283 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0275 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0275]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0282 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0282]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0275)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0282)
}
- for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].UnmarshalMsg(bts)
+ for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "CertType", zb0040)
+ err = msgp.WrapError(err, "struct-from-array", "CertType", zb0041)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0277 []byte
- var zb0278 int
- zb0278, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0284 []byte
+ var zb0285 int
+ zb0285, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- if zb0278 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0278), uint64(maxBitmaskSize))
+ if zb0285 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0285), uint64(maxBitmaskSize))
return
}
- zb0277, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
+ zb0284, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskCertType")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0277)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0284)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0279 int
- zb0279, err = msgp.ReadBytesBytesHeader(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0286 int
+ var zb0287 bool
+ zb0286, zb0287, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
- if zb0279 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0279), uint64(maxAddressBytes))
- return
- }
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0286 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0286), uint64(maxAddressBytes))
err = msgp.WrapError(err, "struct-from-array", "SigCommit")
return
}
+ if zb0287 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0286 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0286]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0286)
+ }
+ for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigCommit", zb0042)
+ return
+ }
+ }
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0280 []byte
- var zb0281 int
- zb0281, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0288 []byte
+ var zb0289 int
+ zb0289, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- if zb0281 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0281), uint64(maxBitmaskSize))
+ if zb0289 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0289), uint64(maxBitmaskSize))
return
}
- zb0280, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0288, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigCommit")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0280)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0288)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0282 int
- var zb0283 bool
- zb0282, zb0283, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0290 int
+ var zb0291 bool
+ zb0290, zb0291, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0282 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0282), uint64(maxEncodedTransactionGroups))
+ if zb0290 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0290), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SignedWeight")
return
}
- if zb0283 {
+ if zb0291 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0282 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0282]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0290 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0290]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0282)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0290)
}
- for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0041)
+ err = msgp.WrapError(err, "struct-from-array", "SignedWeight", zb0043)
return
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0284 []byte
- var zb0285 int
- zb0285, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0292 []byte
+ var zb0293 int
+ zb0293, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- if zb0285 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0285), uint64(maxBitmaskSize))
+ if zb0293 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0293), uint64(maxBitmaskSize))
return
}
- zb0284, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0292, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSignedWeight")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0284)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0292)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0286 int
- var zb0287 bool
- zb0286, zb0287, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0294 int
+ var zb0295 bool
+ zb0294, zb0295, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0286 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0286), uint64(maxEncodedTransactionGroups))
+ if zb0294 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0294), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "SigProofs")
return
}
- if zb0287 {
+ if zb0295 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0286 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0286]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0294 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0294]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0286)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0294)
}
- for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0288 int
- var zb0289 bool
- zb0288, zb0289, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0296 int
+ var zb0297 bool
+ zb0296, zb0297, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044)
return
}
- if zb0288 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0288), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042)
+ if zb0296 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0296), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044)
return
}
- if zb0289 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042]) >= zb0288 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])[:zb0288]
+ if zb0297 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044]) >= zb0296 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])[:zb0296]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = make(certProofs, zb0288)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = make(certProofs, zb0296)
}
- for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].UnmarshalMsg(bts)
+ for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0042, zb0043)
+ err = msgp.WrapError(err, "struct-from-array", "SigProofs", zb0044, zb0045)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0290 []byte
- var zb0291 int
- zb0291, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0298 []byte
+ var zb0299 int
+ zb0299, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- if zb0291 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0291), uint64(maxBitmaskSize))
+ if zb0299 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0299), uint64(maxBitmaskSize))
return
}
- zb0290, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0298, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskSigProofs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0290)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0298)
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0300 int
+ var zb0301 bool
+ zb0300, zb0301, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0300 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0300), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes")
+ return
+ }
+ if zb0301 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0300 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0300]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0300)
+ }
+ for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "SigProofHashTypes", zb0046)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ {
+ var zb0302 []byte
+ var zb0303 int
+ zb0303, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ if zb0303 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0303), uint64(maxBitmaskSize))
+ return
+ }
+ zb0302, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0302)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0292 int
- var zb0293 bool
- zb0292, zb0293, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0304 int
+ var zb0305 bool
+ zb0304, zb0305, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0292 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0292), uint64(maxEncodedTransactionGroups))
+ if zb0304 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0304), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "PartProofs")
return
}
- if zb0293 {
+ if zb0305 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0292 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0292]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0304 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0304]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0292)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0304)
}
- for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0294 int
- var zb0295 bool
- zb0294, zb0295, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0047 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0306 int
+ var zb0307 bool
+ zb0306, zb0307, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047)
return
}
- if zb0294 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0294), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044)
+ if zb0306 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0306), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047)
return
}
- if zb0295 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044]) >= zb0294 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])[:zb0294]
+ if zb0307 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047]) >= zb0306 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])[:zb0306]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = make(certProofs, zb0294)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = make(certProofs, zb0306)
}
- for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].UnmarshalMsg(bts)
+ for zb0048 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0044, zb0045)
+ err = msgp.WrapError(err, "struct-from-array", "PartProofs", zb0047, zb0048)
return
}
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0296 []byte
- var zb0297 int
- zb0297, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0308 []byte
+ var zb0309 int
+ zb0309, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- if zb0297 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0297), uint64(maxBitmaskSize))
+ if zb0309 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0309), uint64(maxBitmaskSize))
return
}
- zb0296, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0308, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskPartProofs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0296)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0308)
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ var zb0310 int
+ var zb0311 bool
+ zb0310, zb0311, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0310 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0310), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes")
+ return
+ }
+ if zb0311 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0310 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0310]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0310)
+ }
+ for zb0049 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "PartProofHashTypes", zb0049)
+ return
+ }
+ }
+ }
+ if zb0053 > 0 {
+ zb0053--
+ {
+ var zb0312 []byte
+ var zb0313 int
+ zb0313, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ if zb0313 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0313), uint64(maxBitmaskSize))
+ return
+ }
+ zb0312, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "BitmaskPartHash")
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0312)
}
}
- if zb0049 > 0 {
- zb0049--
- var zb0298 int
- var zb0299 bool
- zb0298, zb0299, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if zb0053 > 0 {
+ zb0053--
+ var zb0314 int
+ var zb0315 bool
+ zb0314, zb0315, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0298 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0298), uint64(maxEncodedTransactionGroups))
+ if zb0314 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0314), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "struct-from-array", "Reveals")
return
}
- if zb0299 {
+ if zb0315 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0298 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0298]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0314 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0314]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0298)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0314)
}
- for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0300 int
- var zb0301 bool
- zb0300, zb0301, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0050 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0316 int
+ var zb0317 bool
+ zb0316, zb0317, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- if zb0300 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0300), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ if zb0316 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0316), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- if zb0301 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = make(revealMap, zb0300)
+ if zb0317 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = make(revealMap, zb0316)
}
- for zb0300 > 0 {
- var zb0047 uint64
- var zb0048 compactcert.Reveal
- zb0300--
- zb0047, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0316 > 0 {
+ var zb0051 uint64
+ var zb0052 compactcert.Reveal
+ zb0316--
+ zb0051, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050)
return
}
- bts, err = zb0048.UnmarshalMsg(bts)
+ bts, err = zb0052.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0046, zb0047)
+ err = msgp.WrapError(err, "struct-from-array", "Reveals", zb0050, zb0051)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047] = zb0048
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051] = zb0052
}
}
}
- if zb0049 > 0 {
- zb0049--
+ if zb0053 > 0 {
+ zb0053--
{
- var zb0302 []byte
- var zb0303 int
- zb0303, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0318 []byte
+ var zb0319 int
+ zb0319, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- if zb0303 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0303), uint64(maxBitmaskSize))
+ if zb0319 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0319), uint64(maxBitmaskSize))
return
}
- zb0302, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0318, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "struct-from-array", "BitmaskReveals")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0302)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0318)
}
}
- if zb0049 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0049)
+ if zb0053 > 0 {
+ err = msgp.ErrTooManyArrayFields(zb0053)
if err != nil {
err = msgp.WrapError(err, "struct-from-array")
return
@@ -32117,11 +33820,11 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err)
return
}
- if zb0050 {
+ if zb0054 {
(*z) = txGroupsEncodingStub{}
}
- for zb0049 > 0 {
- zb0049--
+ for zb0053 > 0 {
+ zb0053--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
err = msgp.WrapError(err)
@@ -32141,14 +33844,14 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "tgs":
- var zb0304 int
- zb0304, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0320 int
+ zb0320, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "TransactionGroupSizes")
return
}
- if zb0304 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0304), uint64(maxEncodedTransactionGroups))
+ if zb0320 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0320), uint64(maxEncodedTransactionGroups))
return
}
(*z).TransactionGroupSizes, bts, err = msgp.ReadBytesBytes(bts, (*z).TransactionGroupSizes)
@@ -32157,14 +33860,14 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "sig":
- var zb0305 int
- zb0305, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0321 int
+ zb0321, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Sig")
return
}
- if zb0305 > maxSignatureBytes {
- err = msgp.ErrOverflow(uint64(zb0305), uint64(maxSignatureBytes))
+ if zb0321 > maxSignatureBytes {
+ err = msgp.ErrOverflow(uint64(zb0321), uint64(maxSignatureBytes))
return
}
(*z).encodedSignedTxns.Sig, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.Sig)
@@ -32174,33 +33877,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sigbm":
{
- var zb0306 []byte
- var zb0307 int
- zb0307, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0322 []byte
+ var zb0323 int
+ zb0323, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSig")
return
}
- if zb0307 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0307), uint64(maxBitmaskSize))
+ if zb0323 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0323), uint64(maxBitmaskSize))
return
}
- zb0306, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskSig))
+ zb0322, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskSig))
if err != nil {
err = msgp.WrapError(err, "BitmaskSig")
return
}
- (*z).encodedSignedTxns.BitmaskSig = bitmask(zb0306)
+ (*z).encodedSignedTxns.BitmaskSig = bitmask(zb0322)
}
case "msigv":
- var zb0308 int
- zb0308, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0324 int
+ zb0324, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Version")
return
}
- if zb0308 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0308), uint64(maxEncodedTransactionGroups))
+ if zb0324 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0324), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedMsigs.Version, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedMsigs.Version)
@@ -32210,33 +33913,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "msigvbm":
{
- var zb0309 []byte
- var zb0310 int
- zb0310, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0325 []byte
+ var zb0326 int
+ zb0326, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVersion")
return
}
- if zb0310 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0310), uint64(maxBitmaskSize))
+ if zb0326 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0326), uint64(maxBitmaskSize))
return
}
- zb0309, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion))
+ zb0325, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion))
if err != nil {
err = msgp.WrapError(err, "BitmaskVersion")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskVersion = bitmask(zb0309)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskVersion = bitmask(zb0325)
}
case "msigthr":
- var zb0311 int
- zb0311, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0327 int
+ zb0327, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Threshold")
return
}
- if zb0311 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0311), uint64(maxEncodedTransactionGroups))
+ if zb0327 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0327), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedMsigs.Threshold, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedMsigs.Threshold)
@@ -32246,63 +33949,63 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "msigthrbm":
{
- var zb0312 []byte
- var zb0313 int
- zb0313, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0328 []byte
+ var zb0329 int
+ zb0329, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskThreshold")
return
}
- if zb0313 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0313), uint64(maxBitmaskSize))
+ if zb0329 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0329), uint64(maxBitmaskSize))
return
}
- zb0312, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold))
+ zb0328, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold))
if err != nil {
err = msgp.WrapError(err, "BitmaskThreshold")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold = bitmask(zb0312)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold = bitmask(zb0328)
}
case "subsig":
- var zb0314 int
- var zb0315 bool
- zb0314, zb0315, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0330 int
+ var zb0331 bool
+ zb0330, zb0331, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Subsigs")
return
}
- if zb0314 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0314), uint64(maxEncodedTransactionGroups))
+ if zb0330 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0330), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Subsigs")
return
}
- if zb0315 {
+ if zb0331 {
(*z).encodedSignedTxns.encodedMsigs.Subsigs = nil
- } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs) >= zb0314 {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs = ((*z).encodedSignedTxns.encodedMsigs.Subsigs)[:zb0314]
+ } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs) >= zb0330 {
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs = ((*z).encodedSignedTxns.encodedMsigs.Subsigs)[:zb0330]
} else {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0314)
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs = make([][]crypto.MultisigSubsig, zb0330)
}
for zb0001 := range (*z).encodedSignedTxns.encodedMsigs.Subsigs {
- var zb0316 int
- var zb0317 bool
- zb0316, zb0317, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0332 int
+ var zb0333 bool
+ zb0332, zb0333, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Subsigs", zb0001)
return
}
- if zb0316 > crypto.MaxMultisig {
- err = msgp.ErrOverflow(uint64(zb0316), uint64(crypto.MaxMultisig))
+ if zb0332 > crypto.MaxMultisig {
+ err = msgp.ErrOverflow(uint64(zb0332), uint64(crypto.MaxMultisig))
err = msgp.WrapError(err, "Subsigs", zb0001)
return
}
- if zb0317 {
+ if zb0333 {
(*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = nil
- } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001]) >= zb0316 {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = ((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001])[:zb0316]
+ } else if (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] != nil && cap((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001]) >= zb0332 {
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = ((*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001])[:zb0332]
} else {
- (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0316)
+ (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] = make([]crypto.MultisigSubsig, zb0332)
}
for zb0002 := range (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001] {
bts, err = (*z).encodedSignedTxns.encodedMsigs.Subsigs[zb0001][zb0002].UnmarshalMsg(bts)
@@ -32314,53 +34017,53 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "subsigsbm":
{
- var zb0318 []byte
- var zb0319 int
- zb0319, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0334 []byte
+ var zb0335 int
+ zb0335, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSubsigs")
return
}
- if zb0319 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0319), uint64(maxBitmaskSize))
+ if zb0335 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0335), uint64(maxBitmaskSize))
return
}
- zb0318, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs))
+ zb0334, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSubsigs")
return
}
- (*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs = bitmask(zb0318)
+ (*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs = bitmask(zb0334)
}
case "lsigl":
- var zb0320 int
- var zb0321 bool
- zb0320, zb0321, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0336 int
+ var zb0337 bool
+ zb0336, zb0337, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Logic")
return
}
- if zb0320 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0320), uint64(maxEncodedTransactionGroups))
+ if zb0336 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0336), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Logic")
return
}
- if zb0321 {
+ if zb0337 {
(*z).encodedSignedTxns.encodedLsigs.Logic = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.Logic != nil && cap((*z).encodedSignedTxns.encodedLsigs.Logic) >= zb0320 {
- (*z).encodedSignedTxns.encodedLsigs.Logic = ((*z).encodedSignedTxns.encodedLsigs.Logic)[:zb0320]
+ } else if (*z).encodedSignedTxns.encodedLsigs.Logic != nil && cap((*z).encodedSignedTxns.encodedLsigs.Logic) >= zb0336 {
+ (*z).encodedSignedTxns.encodedLsigs.Logic = ((*z).encodedSignedTxns.encodedLsigs.Logic)[:zb0336]
} else {
- (*z).encodedSignedTxns.encodedLsigs.Logic = make([][]byte, zb0320)
+ (*z).encodedSignedTxns.encodedLsigs.Logic = make([][]byte, zb0336)
}
for zb0003 := range (*z).encodedSignedTxns.encodedLsigs.Logic {
- var zb0322 int
- zb0322, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0338 int
+ zb0338, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Logic", zb0003)
return
}
- if zb0322 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0322), uint64(config.MaxLogicSigMaxSize))
+ if zb0338 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0338), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedSignedTxns.encodedLsigs.Logic[zb0003], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedLsigs.Logic[zb0003])
@@ -32371,73 +34074,73 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lsiglbm":
{
- var zb0323 []byte
- var zb0324 int
- zb0324, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0339 []byte
+ var zb0340 int
+ zb0340, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLogic")
return
}
- if zb0324 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0324), uint64(maxBitmaskSize))
+ if zb0340 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0340), uint64(maxBitmaskSize))
return
}
- zb0323, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic))
+ zb0339, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic))
if err != nil {
err = msgp.WrapError(err, "BitmaskLogic")
return
}
- (*z).encodedSignedTxns.encodedLsigs.BitmaskLogic = bitmask(zb0323)
+ (*z).encodedSignedTxns.encodedLsigs.BitmaskLogic = bitmask(zb0339)
}
case "lsigarg":
- var zb0325 int
- var zb0326 bool
- zb0325, zb0326, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0341 int
+ var zb0342 bool
+ zb0341, zb0342, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs")
return
}
- if zb0325 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0325), uint64(maxEncodedTransactionGroups))
+ if zb0341 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0341), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LogicArgs")
return
}
- if zb0326 {
+ if zb0342 {
(*z).encodedSignedTxns.encodedLsigs.LogicArgs = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs) >= zb0325 {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs)[:zb0325]
+ } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs) >= zb0341 {
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs)[:zb0341]
} else {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs = make([][][]byte, zb0325)
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs = make([][][]byte, zb0341)
}
for zb0004 := range (*z).encodedSignedTxns.encodedLsigs.LogicArgs {
- var zb0327 int
- var zb0328 bool
- zb0327, zb0328, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0343 int
+ var zb0344 bool
+ zb0343, zb0344, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs", zb0004)
return
}
- if zb0327 > transactions.EvalMaxArgs {
- err = msgp.ErrOverflow(uint64(zb0327), uint64(transactions.EvalMaxArgs))
+ if zb0343 > transactions.EvalMaxArgs {
+ err = msgp.ErrOverflow(uint64(zb0343), uint64(transactions.EvalMaxArgs))
err = msgp.WrapError(err, "LogicArgs", zb0004)
return
}
- if zb0328 {
+ if zb0344 {
(*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = nil
- } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004]) >= zb0327 {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004])[:zb0327]
+ } else if (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] != nil && cap((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004]) >= zb0343 {
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = ((*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004])[:zb0343]
} else {
- (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0327)
+ (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] = make([][]byte, zb0343)
}
for zb0005 := range (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004] {
- var zb0329 int
- zb0329, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0345 int
+ zb0345, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "LogicArgs", zb0004, zb0005)
return
}
- if zb0329 > config.MaxLogicSigMaxSize {
- err = msgp.ErrOverflow(uint64(zb0329), uint64(config.MaxLogicSigMaxSize))
+ if zb0345 > config.MaxLogicSigMaxSize {
+ err = msgp.ErrOverflow(uint64(zb0345), uint64(config.MaxLogicSigMaxSize))
return
}
(*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004][zb0005], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedLsigs.LogicArgs[zb0004][zb0005])
@@ -32449,33 +34152,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lsigargbm":
{
- var zb0330 []byte
- var zb0331 int
- zb0331, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0346 []byte
+ var zb0347 int
+ zb0347, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLogicArgs")
return
}
- if zb0331 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0331), uint64(maxBitmaskSize))
+ if zb0347 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0347), uint64(maxBitmaskSize))
return
}
- zb0330, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs))
+ zb0346, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs))
if err != nil {
err = msgp.WrapError(err, "BitmaskLogicArgs")
return
}
- (*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs = bitmask(zb0330)
+ (*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs = bitmask(zb0346)
}
case "sgnr":
- var zb0332 int
- zb0332, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0348 int
+ zb0348, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AuthAddr")
return
}
- if zb0332 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0332), uint64(maxAddressBytes))
+ if zb0348 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0348), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.AuthAddr, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.AuthAddr)
@@ -32485,33 +34188,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sgnrbm":
{
- var zb0333 []byte
- var zb0334 int
- zb0334, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0349 []byte
+ var zb0350 int
+ zb0350, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAuthAddr")
return
}
- if zb0334 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0334), uint64(maxBitmaskSize))
+ if zb0350 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0350), uint64(maxBitmaskSize))
return
}
- zb0333, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskAuthAddr))
+ zb0349, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.BitmaskAuthAddr))
if err != nil {
err = msgp.WrapError(err, "BitmaskAuthAddr")
return
}
- (*z).encodedSignedTxns.BitmaskAuthAddr = bitmask(zb0333)
+ (*z).encodedSignedTxns.BitmaskAuthAddr = bitmask(zb0349)
}
case "type":
- var zb0335 int
- zb0335, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0351 int
+ zb0351, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "TxType")
return
}
- if zb0335 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0335), uint64(maxEncodedTransactionGroups))
+ if zb0351 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0351), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedTxns.TxType, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.TxType)
@@ -32521,23 +34224,23 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "typebm":
{
- var zb0336 []byte
- var zb0337 int
- zb0337, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0352 []byte
+ var zb0353 int
+ zb0353, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- if zb0337 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0337), uint64(maxBitmaskSize))
+ if zb0353 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0353), uint64(maxBitmaskSize))
return
}
- zb0336, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.BitmaskTxType))
+ zb0352, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.BitmaskTxType))
if err != nil {
err = msgp.WrapError(err, "BitmaskTxType")
return
}
- (*z).encodedSignedTxns.encodedTxns.BitmaskTxType = bitmask(zb0336)
+ (*z).encodedSignedTxns.encodedTxns.BitmaskTxType = bitmask(zb0352)
}
case "typeo":
(*z).encodedSignedTxns.encodedTxns.TxTypeOffset, bts, err = msgp.ReadByteBytes(bts)
@@ -32546,14 +34249,14 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "snd":
- var zb0338 int
- zb0338, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0354 int
+ zb0354, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Sender")
return
}
- if zb0338 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0338), uint64(maxAddressBytes))
+ if zb0354 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0354), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender)
@@ -32563,43 +34266,43 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "sndbm":
{
- var zb0339 []byte
- var zb0340 int
- zb0340, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0355 []byte
+ var zb0356 int
+ zb0356, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- if zb0340 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0340), uint64(maxBitmaskSize))
+ if zb0356 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0356), uint64(maxBitmaskSize))
return
}
- zb0339, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender))
+ zb0355, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskSender")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0339)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender = bitmask(zb0355)
}
case "fee":
- var zb0341 int
- var zb0342 bool
- zb0341, zb0342, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0357 int
+ var zb0358 bool
+ zb0357, zb0358, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Fee")
return
}
- if zb0341 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0341), uint64(maxEncodedTransactionGroups))
+ if zb0357 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0357), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Fee")
return
}
- if zb0342 {
+ if zb0358 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) >= zb0341 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee)[:zb0341]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) >= zb0357 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee)[:zb0357]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0341)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee = make([]basics.MicroAlgos, zb0357)
}
for zb0006 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee[zb0006].UnmarshalMsg(bts)
@@ -32610,43 +34313,43 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "feebm":
{
- var zb0343 []byte
- var zb0344 int
- zb0344, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0359 []byte
+ var zb0360 int
+ zb0360, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- if zb0344 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0344), uint64(maxBitmaskSize))
+ if zb0360 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0360), uint64(maxBitmaskSize))
return
}
- zb0343, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee))
+ zb0359, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee))
if err != nil {
err = msgp.WrapError(err, "BitmaskFee")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0343)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee = bitmask(zb0359)
}
case "fv":
- var zb0345 int
- var zb0346 bool
- zb0345, zb0346, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0361 int
+ var zb0362 bool
+ zb0361, zb0362, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0345 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0345), uint64(maxEncodedTransactionGroups))
+ if zb0361 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0361), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FirstValid")
return
}
- if zb0346 {
+ if zb0362 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) >= zb0345 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid)[:zb0345]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) >= zb0361 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid)[:zb0361]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0345)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid = make([]basics.Round, zb0361)
}
for zb0007 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid[zb0007].UnmarshalMsg(bts)
@@ -32657,43 +34360,43 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fvbm":
{
- var zb0347 []byte
- var zb0348 int
- zb0348, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0363 []byte
+ var zb0364 int
+ zb0364, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- if zb0348 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0348), uint64(maxBitmaskSize))
+ if zb0364 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0364), uint64(maxBitmaskSize))
return
}
- zb0347, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
+ zb0363, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskFirstValid")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0347)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid = bitmask(zb0363)
}
case "lv":
- var zb0349 int
- var zb0350 bool
- zb0349, zb0350, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0365 int
+ var zb0366 bool
+ zb0365, zb0366, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0349 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0349), uint64(maxEncodedTransactionGroups))
+ if zb0365 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0365), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LastValid")
return
}
- if zb0350 {
+ if zb0366 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) >= zb0349 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid)[:zb0349]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) >= zb0365 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid)[:zb0365]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0349)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid = make([]basics.Round, zb0365)
}
for zb0008 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid[zb0008].UnmarshalMsg(bts)
@@ -32704,53 +34407,53 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lvbm":
{
- var zb0351 []byte
- var zb0352 int
- zb0352, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0367 []byte
+ var zb0368 int
+ zb0368, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- if zb0352 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0352), uint64(maxBitmaskSize))
+ if zb0368 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0368), uint64(maxBitmaskSize))
return
}
- zb0351, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid))
+ zb0367, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid))
if err != nil {
err = msgp.WrapError(err, "BitmaskLastValid")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0351)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid = bitmask(zb0367)
}
case "note":
- var zb0353 int
- var zb0354 bool
- zb0353, zb0354, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0369 int
+ var zb0370 bool
+ zb0369, zb0370, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Note")
return
}
- if zb0353 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0353), uint64(maxEncodedTransactionGroups))
+ if zb0369 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0369), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Note")
return
}
- if zb0354 {
+ if zb0370 {
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) >= zb0353 {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note)[:zb0353]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) >= zb0369 {
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = ((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note)[:zb0369]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0353)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note = make([][]byte, zb0369)
}
for zb0009 := range (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note {
- var zb0355 int
- zb0355, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0371 int
+ zb0371, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Note", zb0009)
return
}
- if zb0355 > config.MaxTxnNoteBytes {
- err = msgp.ErrOverflow(uint64(zb0355), uint64(config.MaxTxnNoteBytes))
+ if zb0371 > config.MaxTxnNoteBytes {
+ err = msgp.ErrOverflow(uint64(zb0371), uint64(config.MaxTxnNoteBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note[zb0009], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note[zb0009])
@@ -32761,73 +34464,73 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "notebm":
{
- var zb0356 []byte
- var zb0357 int
- zb0357, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0372 []byte
+ var zb0373 int
+ zb0373, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- if zb0357 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0357), uint64(maxBitmaskSize))
+ if zb0373 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0373), uint64(maxBitmaskSize))
return
}
- zb0356, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote))
+ zb0372, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote))
if err != nil {
err = msgp.WrapError(err, "BitmaskNote")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0356)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote = bitmask(zb0372)
}
case "genbm":
{
- var zb0358 []byte
- var zb0359 int
- zb0359, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0374 []byte
+ var zb0375 int
+ zb0375, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- if zb0359 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0359), uint64(maxBitmaskSize))
+ if zb0375 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0375), uint64(maxBitmaskSize))
return
}
- zb0358, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
+ zb0374, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID))
if err != nil {
err = msgp.WrapError(err, "BitmaskGenesisID")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0358)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID = bitmask(zb0374)
}
case "grpbm":
{
- var zb0360 []byte
- var zb0361 int
- zb0361, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0376 []byte
+ var zb0377 int
+ zb0377, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- if zb0361 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0361), uint64(maxBitmaskSize))
+ if zb0377 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0377), uint64(maxBitmaskSize))
return
}
- zb0360, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup))
+ zb0376, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup))
if err != nil {
err = msgp.WrapError(err, "BitmaskGroup")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0360)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup = bitmask(zb0376)
}
case "lx":
- var zb0362 int
- zb0362, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0378 int
+ zb0378, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Lease")
return
}
- if zb0362 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0362), uint64(maxAddressBytes))
+ if zb0378 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0378), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease)
@@ -32837,33 +34540,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "lxbm":
{
- var zb0363 []byte
- var zb0364 int
- zb0364, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0379 []byte
+ var zb0380 int
+ zb0380, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- if zb0364 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0364), uint64(maxBitmaskSize))
+ if zb0380 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0380), uint64(maxBitmaskSize))
return
}
- zb0363, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease))
+ zb0379, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease))
if err != nil {
err = msgp.WrapError(err, "BitmaskLease")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0363)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease = bitmask(zb0379)
}
case "rekey":
- var zb0365 int
- zb0365, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0381 int
+ zb0381, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "RekeyTo")
return
}
- if zb0365 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0365), uint64(maxAddressBytes))
+ if zb0381 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0381), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo)
@@ -32873,33 +34576,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rekeybm":
{
- var zb0366 []byte
- var zb0367 int
- zb0367, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0382 []byte
+ var zb0383 int
+ zb0383, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- if zb0367 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0367), uint64(maxBitmaskSize))
+ if zb0383 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0383), uint64(maxBitmaskSize))
return
}
- zb0366, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
+ zb0382, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskRekeyTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0366)
+ (*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo = bitmask(zb0382)
}
case "votekey":
- var zb0368 int
- zb0368, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0384 int
+ zb0384, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "VotePK")
return
}
- if zb0368 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0368), uint64(maxAddressBytes))
+ if zb0384 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0384), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK)
@@ -32908,14 +34611,14 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "selkey":
- var zb0369 int
- zb0369, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0385 int
+ zb0385, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "SelectionPK")
return
}
- if zb0369 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0369), uint64(maxAddressBytes))
+ if zb0385 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0385), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK)
@@ -32924,24 +34627,24 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
case "votefst":
- var zb0370 int
- var zb0371 bool
- zb0370, zb0371, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0386 int
+ var zb0387 bool
+ zb0386, zb0387, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0370 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0370), uint64(maxEncodedTransactionGroups))
+ if zb0386 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0386), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteFirst")
return
}
- if zb0371 {
+ if zb0387 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0370 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0370]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) >= zb0386 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst)[:zb0386]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0370)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst = make([]basics.Round, zb0386)
}
for zb0010 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst[zb0010].UnmarshalMsg(bts)
@@ -32952,43 +34655,43 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votefstbm":
{
- var zb0372 []byte
- var zb0373 int
- zb0373, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0388 []byte
+ var zb0389 int
+ zb0389, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- if zb0373 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0373), uint64(maxBitmaskSize))
+ if zb0389 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0389), uint64(maxBitmaskSize))
return
}
- zb0372, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
+ zb0388, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteFirst")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0372)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst = bitmask(zb0388)
}
case "votelst":
- var zb0374 int
- var zb0375 bool
- zb0374, zb0375, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0390 int
+ var zb0391 bool
+ zb0390, zb0391, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0374 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0374), uint64(maxEncodedTransactionGroups))
+ if zb0390 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0390), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteLast")
return
}
- if zb0375 {
+ if zb0391 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0374 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0374]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) >= zb0390 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast)[:zb0390]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0374)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast = make([]basics.Round, zb0390)
}
for zb0011 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast {
bts, err = (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].UnmarshalMsg(bts)
@@ -32999,43 +34702,43 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votelstbm":
{
- var zb0376 []byte
- var zb0377 int
- zb0377, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0392 []byte
+ var zb0393 int
+ zb0393, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- if zb0377 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0377), uint64(maxBitmaskSize))
+ if zb0393 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0393), uint64(maxBitmaskSize))
return
}
- zb0376, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
+ zb0392, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast))
if err != nil {
err = msgp.WrapError(err, "BitmaskVoteLast")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0376)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast = bitmask(zb0392)
}
case "votekd":
- var zb0378 int
- var zb0379 bool
- zb0378, zb0379, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0394 int
+ var zb0395 bool
+ zb0394, zb0395, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0378 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0378), uint64(maxEncodedTransactionGroups))
+ if zb0394 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0394), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "VoteKeyDilution")
return
}
- if zb0379 {
+ if zb0395 {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0378 {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0378]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) >= zb0394 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution)[:zb0394]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0378)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution = make([]uint64, zb0394)
}
for zb0012 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution {
(*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution[zb0012], bts, err = msgp.ReadUint64Bytes(bts)
@@ -33046,53 +34749,96 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "votekbm":
{
- var zb0380 []byte
- var zb0381 int
- zb0381, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0396 []byte
+ var zb0397 int
+ zb0397, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- if zb0381 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0381), uint64(maxBitmaskSize))
+ if zb0397 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0397), uint64(maxBitmaskSize))
return
}
- zb0380, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
+ zb0396, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys))
if err != nil {
err = msgp.WrapError(err, "BitmaskKeys")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0380)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys = bitmask(zb0396)
}
case "nonpartbm":
{
- var zb0382 []byte
- var zb0383 int
- zb0383, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0398 []byte
+ var zb0399 int
+ zb0399, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- if zb0383 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0383), uint64(maxBitmaskSize))
+ if zb0399 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0399), uint64(maxBitmaskSize))
return
}
- zb0382, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
+ zb0398, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation))
if err != nil {
err = msgp.WrapError(err, "BitmaskNonparticipation")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0382)
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation = bitmask(zb0398)
+ }
+ case "vldrt":
+ var zb0400 int
+ var zb0401 bool
+ zb0400, zb0401, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0400 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0400), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "HasValidRoot")
+ return
+ }
+ if zb0401 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot) >= zb0400 {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = ((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot)[:zb0400]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot = make([]bool, zb0400)
+ }
+ for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot {
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot[zb0013], bts, err = msgp.ReadBoolBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "HasValidRoot", zb0013)
+ return
+ }
+ }
+ case "comt":
+ var zb0402 int
+ zb0402, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
+ }
+ if zb0402 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0402), uint64(maxEncodedTransactionGroups))
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot)
+ if err != nil {
+ err = msgp.WrapError(err, "CommitmentRoot")
+ return
}
case "rcv":
- var zb0384 int
- zb0384, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0403 int
+ zb0403, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Receiver")
return
}
- if zb0384 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0384), uint64(maxAddressBytes))
+ if zb0403 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0403), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver)
@@ -33102,80 +34848,80 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rcvbm":
{
- var zb0385 []byte
- var zb0386 int
- zb0386, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0404 []byte
+ var zb0405 int
+ zb0405, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- if zb0386 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0386), uint64(maxBitmaskSize))
+ if zb0405 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0405), uint64(maxBitmaskSize))
return
}
- zb0385, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
+ zb0404, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskReceiver")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0385)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver = bitmask(zb0404)
}
case "amt":
- var zb0387 int
- var zb0388 bool
- zb0387, zb0388, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0406 int
+ var zb0407 bool
+ zb0406, zb0407, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Amount")
return
}
- if zb0387 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0387), uint64(maxEncodedTransactionGroups))
+ if zb0406 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0406), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Amount")
return
}
- if zb0388 {
+ if zb0407 {
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) >= zb0387 {
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount)[:zb0387]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) >= zb0406 {
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = ((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount)[:zb0406]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0387)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount = make([]basics.MicroAlgos, zb0406)
}
- for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0013].UnmarshalMsg(bts)
+ for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0014].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Amount", zb0013)
+ err = msgp.WrapError(err, "Amount", zb0014)
return
}
}
case "amtbm":
{
- var zb0389 []byte
- var zb0390 int
- zb0390, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0408 []byte
+ var zb0409 int
+ zb0409, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- if zb0390 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0390), uint64(maxBitmaskSize))
+ if zb0409 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0409), uint64(maxBitmaskSize))
return
}
- zb0389, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
+ zb0408, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAmount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0389)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount = bitmask(zb0408)
}
case "close":
- var zb0391 int
- zb0391, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0410 int
+ zb0410, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "CloseRemainderTo")
return
}
- if zb0391 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0391), uint64(maxAddressBytes))
+ if zb0410 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0410), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo)
@@ -33185,335 +34931,335 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "closebm":
{
- var zb0392 []byte
- var zb0393 int
- zb0393, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0411 []byte
+ var zb0412 int
+ zb0412, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- if zb0393 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0393), uint64(maxBitmaskSize))
+ if zb0412 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0412), uint64(maxBitmaskSize))
return
}
- zb0392, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
+ zb0411, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskCloseRemainderTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0392)
+ (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo = bitmask(zb0411)
}
case "caid":
- var zb0394 int
- var zb0395 bool
- zb0394, zb0395, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0413 int
+ var zb0414 bool
+ zb0413, zb0414, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0394 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0394), uint64(maxEncodedTransactionGroups))
+ if zb0413 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0413), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ConfigAsset")
return
}
- if zb0395 {
+ if zb0414 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0394 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0394]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) >= zb0413 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset)[:zb0413]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0394)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset = make([]basics.AssetIndex, zb0413)
}
- for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].UnmarshalMsg(bts)
+ for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ConfigAsset", zb0014)
+ err = msgp.WrapError(err, "ConfigAsset", zb0015)
return
}
}
case "caidbm":
{
- var zb0396 []byte
- var zb0397 int
- zb0397, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0415 []byte
+ var zb0416 int
+ zb0416, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- if zb0397 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0397), uint64(maxBitmaskSize))
+ if zb0416 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0416), uint64(maxBitmaskSize))
return
}
- zb0396, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
+ zb0415, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskConfigAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0396)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset = bitmask(zb0415)
}
case "t":
- var zb0398 int
- var zb0399 bool
- zb0398, zb0399, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0417 int
+ var zb0418 bool
+ zb0417, zb0418, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Total")
return
}
- if zb0398 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0398), uint64(maxEncodedTransactionGroups))
+ if zb0417 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0417), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Total")
return
}
- if zb0399 {
+ if zb0418 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0398 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0398]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) >= zb0417 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total)[:zb0417]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0398)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total = make([]uint64, zb0417)
}
- for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0015], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total[zb0016], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Total", zb0015)
+ err = msgp.WrapError(err, "Total", zb0016)
return
}
}
case "tbm":
{
- var zb0400 []byte
- var zb0401 int
- zb0401, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0419 []byte
+ var zb0420 int
+ zb0420, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- if zb0401 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0401), uint64(maxBitmaskSize))
+ if zb0420 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0420), uint64(maxBitmaskSize))
return
}
- zb0400, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
+ zb0419, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal))
if err != nil {
err = msgp.WrapError(err, "BitmaskTotal")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0400)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal = bitmask(zb0419)
}
case "dc":
- var zb0402 int
- var zb0403 bool
- zb0402, zb0403, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0421 int
+ var zb0422 bool
+ zb0421, zb0422, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0402 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0402), uint64(maxEncodedTransactionGroups))
+ if zb0421 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0421), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Decimals")
return
}
- if zb0403 {
+ if zb0422 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0402 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0402]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) >= zb0421 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals)[:zb0421]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0402)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals = make([]uint32, zb0421)
}
- for zb0016 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0016], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals[zb0017], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Decimals", zb0016)
+ err = msgp.WrapError(err, "Decimals", zb0017)
return
}
}
case "dcbm":
{
- var zb0404 []byte
- var zb0405 int
- zb0405, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0423 []byte
+ var zb0424 int
+ zb0424, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- if zb0405 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0405), uint64(maxBitmaskSize))
+ if zb0424 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0424), uint64(maxBitmaskSize))
return
}
- zb0404, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
+ zb0423, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals))
if err != nil {
err = msgp.WrapError(err, "BitmaskDecimals")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0404)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals = bitmask(zb0423)
}
case "dfbm":
{
- var zb0406 []byte
- var zb0407 int
- zb0407, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0425 []byte
+ var zb0426 int
+ zb0426, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- if zb0407 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0407), uint64(maxBitmaskSize))
+ if zb0426 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0426), uint64(maxBitmaskSize))
return
}
- zb0406, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
+ zb0425, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskDefaultFrozen")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0406)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen = bitmask(zb0425)
}
case "un":
- var zb0408 int
- var zb0409 bool
- zb0408, zb0409, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0427 int
+ var zb0428 bool
+ zb0427, zb0428, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0408 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0408), uint64(maxEncodedTransactionGroups))
+ if zb0427 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0427), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "UnitName")
return
}
- if zb0409 {
+ if zb0428 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0408 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0408]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) >= zb0427 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName)[:zb0427]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0408)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName = make([]string, zb0427)
}
- for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017], bts, err = msgp.ReadStringBytes(bts)
+ for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "UnitName", zb0017)
+ err = msgp.WrapError(err, "UnitName", zb0018)
return
}
}
case "unbm":
{
- var zb0410 []byte
- var zb0411 int
- zb0411, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0429 []byte
+ var zb0430 int
+ zb0430, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- if zb0411 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0411), uint64(maxBitmaskSize))
+ if zb0430 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0430), uint64(maxBitmaskSize))
return
}
- zb0410, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
+ zb0429, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName))
if err != nil {
err = msgp.WrapError(err, "BitmaskUnitName")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0410)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName = bitmask(zb0429)
}
case "an":
- var zb0412 int
- var zb0413 bool
- zb0412, zb0413, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0431 int
+ var zb0432 bool
+ zb0431, zb0432, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0412 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0412), uint64(maxEncodedTransactionGroups))
+ if zb0431 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0431), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetName")
return
}
- if zb0413 {
+ if zb0432 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0412 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0412]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) >= zb0431 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName)[:zb0431]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0412)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName = make([]string, zb0431)
}
- for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018], bts, err = msgp.ReadStringBytes(bts)
+ for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetName", zb0018)
+ err = msgp.WrapError(err, "AssetName", zb0019)
return
}
}
case "anbm":
{
- var zb0414 []byte
- var zb0415 int
- zb0415, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0433 []byte
+ var zb0434 int
+ zb0434, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- if zb0415 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0415), uint64(maxBitmaskSize))
+ if zb0434 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0434), uint64(maxBitmaskSize))
return
}
- zb0414, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
+ zb0433, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetName")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0414)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName = bitmask(zb0433)
}
case "au":
- var zb0416 int
- var zb0417 bool
- zb0416, zb0417, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0435 int
+ var zb0436 bool
+ zb0435, zb0436, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "URL")
return
}
- if zb0416 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0416), uint64(maxEncodedTransactionGroups))
+ if zb0435 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0435), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "URL")
return
}
- if zb0417 {
+ if zb0436 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0416 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0416]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) >= zb0435 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = ((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL)[:zb0435]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0416)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL = make([]string, zb0435)
}
- for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019], bts, err = msgp.ReadStringBytes(bts)
+ for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020], bts, err = msgp.ReadStringBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "URL", zb0019)
+ err = msgp.WrapError(err, "URL", zb0020)
return
}
}
case "aubm":
{
- var zb0418 []byte
- var zb0419 int
- zb0419, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0437 []byte
+ var zb0438 int
+ zb0438, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- if zb0419 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0419), uint64(maxBitmaskSize))
+ if zb0438 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0438), uint64(maxBitmaskSize))
return
}
- zb0418, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
+ zb0437, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL))
if err != nil {
err = msgp.WrapError(err, "BitmaskURL")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0418)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL = bitmask(zb0437)
}
case "am":
- var zb0420 int
- zb0420, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0439 int
+ zb0439, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "MetadataHash")
return
}
- if zb0420 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0420), uint64(maxAddressBytes))
+ if zb0439 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0439), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash)
@@ -33523,33 +35269,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "ambm":
{
- var zb0421 []byte
- var zb0422 int
- zb0422, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0440 []byte
+ var zb0441 int
+ zb0441, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- if zb0422 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0422), uint64(maxBitmaskSize))
+ if zb0441 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0441), uint64(maxBitmaskSize))
return
}
- zb0421, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
+ zb0440, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash))
if err != nil {
err = msgp.WrapError(err, "BitmaskMetadataHash")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0421)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash = bitmask(zb0440)
}
case "m":
- var zb0423 int
- zb0423, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0442 int
+ zb0442, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Manager")
return
}
- if zb0423 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0423), uint64(maxAddressBytes))
+ if zb0442 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0442), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager)
@@ -33559,33 +35305,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "mbm":
{
- var zb0424 []byte
- var zb0425 int
- zb0425, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0443 []byte
+ var zb0444 int
+ zb0444, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- if zb0425 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0425), uint64(maxBitmaskSize))
+ if zb0444 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0444), uint64(maxBitmaskSize))
return
}
- zb0424, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
+ zb0443, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager))
if err != nil {
err = msgp.WrapError(err, "BitmaskManager")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0424)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager = bitmask(zb0443)
}
case "r":
- var zb0426 int
- zb0426, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0445 int
+ zb0445, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Reserve")
return
}
- if zb0426 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0426), uint64(maxAddressBytes))
+ if zb0445 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0445), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve)
@@ -33595,33 +35341,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "rbm":
{
- var zb0427 []byte
- var zb0428 int
- zb0428, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0446 []byte
+ var zb0447 int
+ zb0447, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- if zb0428 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0428), uint64(maxBitmaskSize))
+ if zb0447 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0447), uint64(maxBitmaskSize))
return
}
- zb0427, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
+ zb0446, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve))
if err != nil {
err = msgp.WrapError(err, "BitmaskReserve")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0427)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve = bitmask(zb0446)
}
case "f":
- var zb0429 int
- zb0429, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0448 int
+ zb0448, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Freeze")
return
}
- if zb0429 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0429), uint64(maxAddressBytes))
+ if zb0448 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0448), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze)
@@ -33631,33 +35377,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "fbm":
{
- var zb0430 []byte
- var zb0431 int
- zb0431, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0449 []byte
+ var zb0450 int
+ zb0450, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- if zb0431 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0431), uint64(maxBitmaskSize))
+ if zb0450 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0450), uint64(maxBitmaskSize))
return
}
- zb0430, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
+ zb0449, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreeze")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0430)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze = bitmask(zb0449)
}
case "c":
- var zb0432 int
- zb0432, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0451 int
+ zb0451, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "Clawback")
return
}
- if zb0432 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0432), uint64(maxAddressBytes))
+ if zb0451 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0451), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback)
@@ -33667,127 +35413,127 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "cbm":
{
- var zb0433 []byte
- var zb0434 int
- zb0434, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0452 []byte
+ var zb0453 int
+ zb0453, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- if zb0434 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0434), uint64(maxBitmaskSize))
+ if zb0453 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0453), uint64(maxBitmaskSize))
return
}
- zb0433, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
+ zb0452, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback))
if err != nil {
err = msgp.WrapError(err, "BitmaskClawback")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0433)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback = bitmask(zb0452)
}
case "xaid":
- var zb0435 int
- var zb0436 bool
- zb0435, zb0436, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0454 int
+ var zb0455 bool
+ zb0454, zb0455, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0435 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0435), uint64(maxEncodedTransactionGroups))
+ if zb0454 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0454), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "XferAsset")
return
}
- if zb0436 {
+ if zb0455 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0435 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0435]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) >= zb0454 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset)[:zb0454]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0435)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset = make([]basics.AssetIndex, zb0454)
}
- for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].UnmarshalMsg(bts)
+ for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "XferAsset", zb0020)
+ err = msgp.WrapError(err, "XferAsset", zb0021)
return
}
}
case "xaidbm":
{
- var zb0437 []byte
- var zb0438 int
- zb0438, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0456 []byte
+ var zb0457 int
+ zb0457, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- if zb0438 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0438), uint64(maxBitmaskSize))
+ if zb0457 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0457), uint64(maxBitmaskSize))
return
}
- zb0437, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
+ zb0456, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskXferAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0437)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset = bitmask(zb0456)
}
case "aamt":
- var zb0439 int
- var zb0440 bool
- zb0439, zb0440, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0458 int
+ var zb0459 bool
+ zb0458, zb0459, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0439 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0439), uint64(maxEncodedTransactionGroups))
+ if zb0458 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0458), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "AssetAmount")
return
}
- if zb0440 {
+ if zb0459 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0439 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0439]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) >= zb0458 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = ((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount)[:zb0458]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0439)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount = make([]uint64, zb0458)
}
- for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0021], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount[zb0022], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "AssetAmount", zb0021)
+ err = msgp.WrapError(err, "AssetAmount", zb0022)
return
}
}
case "aamtbm":
{
- var zb0441 []byte
- var zb0442 int
- zb0442, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0460 []byte
+ var zb0461 int
+ zb0461, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- if zb0442 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0442), uint64(maxBitmaskSize))
+ if zb0461 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0461), uint64(maxBitmaskSize))
return
}
- zb0441, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
+ zb0460, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetAmount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0441)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount = bitmask(zb0460)
}
case "asnd":
- var zb0443 int
- zb0443, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0462 int
+ zb0462, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetSender")
return
}
- if zb0443 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0443), uint64(maxAddressBytes))
+ if zb0462 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0462), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender)
@@ -33797,33 +35543,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "asndbm":
{
- var zb0444 []byte
- var zb0445 int
- zb0445, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0463 []byte
+ var zb0464 int
+ zb0464, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- if zb0445 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0445), uint64(maxBitmaskSize))
+ if zb0464 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0464), uint64(maxBitmaskSize))
return
}
- zb0444, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
+ zb0463, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetSender")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0444)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender = bitmask(zb0463)
}
case "arcv":
- var zb0446 int
- zb0446, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0465 int
+ zb0465, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetReceiver")
return
}
- if zb0446 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0446), uint64(maxAddressBytes))
+ if zb0465 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0465), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver)
@@ -33833,33 +35579,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "arcvbm":
{
- var zb0447 []byte
- var zb0448 int
- zb0448, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0466 []byte
+ var zb0467 int
+ zb0467, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- if zb0448 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0448), uint64(maxBitmaskSize))
+ if zb0467 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0467), uint64(maxBitmaskSize))
return
}
- zb0447, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
+ zb0466, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetReceiver")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0447)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver = bitmask(zb0466)
}
case "aclose":
- var zb0449 int
- zb0449, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0468 int
+ zb0468, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "AssetCloseTo")
return
}
- if zb0449 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0449), uint64(maxAddressBytes))
+ if zb0468 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0468), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo)
@@ -33869,33 +35615,33 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "aclosebm":
{
- var zb0450 []byte
- var zb0451 int
- zb0451, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0469 []byte
+ var zb0470 int
+ zb0470, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- if zb0451 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0451), uint64(maxBitmaskSize))
+ if zb0470 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0470), uint64(maxBitmaskSize))
return
}
- zb0450, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
+ zb0469, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetCloseTo")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0450)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo = bitmask(zb0469)
}
case "fadd":
- var zb0452 int
- zb0452, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0471 int
+ zb0471, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAccount")
return
}
- if zb0452 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0452), uint64(maxAddressBytes))
+ if zb0471 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0471), uint64(maxAddressBytes))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount)
@@ -33905,147 +35651,147 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "faddbm":
{
- var zb0453 []byte
- var zb0454 int
- zb0454, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0472 []byte
+ var zb0473 int
+ zb0473, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- if zb0454 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0454), uint64(maxBitmaskSize))
+ if zb0473 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0473), uint64(maxBitmaskSize))
return
}
- zb0453, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
+ zb0472, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAccount")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0453)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount = bitmask(zb0472)
}
case "faid":
- var zb0455 int
- var zb0456 bool
- zb0455, zb0456, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0474 int
+ var zb0475 bool
+ zb0474, zb0475, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0455 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0455), uint64(maxEncodedTransactionGroups))
+ if zb0474 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0474), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "FreezeAsset")
return
}
- if zb0456 {
+ if zb0475 {
(*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0455 {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0455]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) >= zb0474 {
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = ((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset)[:zb0474]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0455)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset = make([]basics.AssetIndex, zb0474)
}
- for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].UnmarshalMsg(bts)
+ for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "FreezeAsset", zb0022)
+ err = msgp.WrapError(err, "FreezeAsset", zb0023)
return
}
}
case "faidbm":
{
- var zb0457 []byte
- var zb0458 int
- zb0458, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0476 []byte
+ var zb0477 int
+ zb0477, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- if zb0458 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0458), uint64(maxBitmaskSize))
+ if zb0477 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0477), uint64(maxBitmaskSize))
return
}
- zb0457, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
+ zb0476, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset))
if err != nil {
err = msgp.WrapError(err, "BitmaskFreezeAsset")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0457)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset = bitmask(zb0476)
}
case "afrzbm":
{
- var zb0459 []byte
- var zb0460 int
- zb0460, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0478 []byte
+ var zb0479 int
+ zb0479, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- if zb0460 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0460), uint64(maxBitmaskSize))
+ if zb0479 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0479), uint64(maxBitmaskSize))
return
}
- zb0459, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
+ zb0478, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen))
if err != nil {
err = msgp.WrapError(err, "BitmaskAssetFrozen")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0459)
+ (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen = bitmask(zb0478)
}
case "apid":
- var zb0461 int
- var zb0462 bool
- zb0461, zb0462, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0480 int
+ var zb0481 bool
+ zb0480, zb0481, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0461 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0461), uint64(maxEncodedTransactionGroups))
+ if zb0480 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0480), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationID")
return
}
- if zb0462 {
+ if zb0481 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0461 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0461]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) >= zb0480 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID)[:zb0480]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0461)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID = make([]basics.AppIndex, zb0480)
}
- for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].UnmarshalMsg(bts)
+ for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationID", zb0023)
+ err = msgp.WrapError(err, "ApplicationID", zb0024)
return
}
}
case "apidbm":
{
- var zb0463 []byte
- var zb0464 int
- zb0464, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0482 []byte
+ var zb0483 int
+ zb0483, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- if zb0464 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0464), uint64(maxBitmaskSize))
+ if zb0483 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0483), uint64(maxBitmaskSize))
return
}
- zb0463, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
+ zb0482, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationID")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0463)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID = bitmask(zb0482)
}
case "apan":
- var zb0465 int
- zb0465, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0484 int
+ zb0484, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "OnCompletion")
return
}
- if zb0465 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0465), uint64(maxEncodedTransactionGroups))
+ if zb0484 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0484), uint64(maxEncodedTransactionGroups))
return
}
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion)
@@ -34055,1040 +35801,1145 @@ func (z *txGroupsEncodingStub) UnmarshalMsg(bts []byte) (o []byte, err error) {
}
case "apanbm":
{
- var zb0466 []byte
- var zb0467 int
- zb0467, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0485 []byte
+ var zb0486 int
+ zb0486, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- if zb0467 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0467), uint64(maxBitmaskSize))
+ if zb0486 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0486), uint64(maxBitmaskSize))
return
}
- zb0466, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
+ zb0485, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion))
if err != nil {
err = msgp.WrapError(err, "BitmaskOnCompletion")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0466)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion = bitmask(zb0485)
}
case "apaa":
- var zb0468 int
- var zb0469 bool
- zb0468, zb0469, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0487 int
+ var zb0488 bool
+ zb0487, zb0488, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0468 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0468), uint64(maxEncodedTransactionGroups))
+ if zb0487 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0487), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApplicationArgs")
return
}
- if zb0469 {
+ if zb0488 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0468 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0468]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) >= zb0487 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs)[:zb0487]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0468)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs = make([]applicationArgs, zb0487)
}
- for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
- var zb0470 int
- var zb0471 bool
- zb0470, zb0471, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ var zb0489 int
+ var zb0490 bool
+ zb0489, zb0490, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0024)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025)
return
}
- if zb0470 > transactions.EncodedMaxApplicationArgs {
- err = msgp.ErrOverflow(uint64(zb0470), uint64(transactions.EncodedMaxApplicationArgs))
- err = msgp.WrapError(err, "ApplicationArgs", zb0024)
+ if zb0489 > transactions.EncodedMaxApplicationArgs {
+ err = msgp.ErrOverflow(uint64(zb0489), uint64(transactions.EncodedMaxApplicationArgs))
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025)
return
}
- if zb0471 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024]) >= zb0470 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024])[:zb0470]
+ if zb0490 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025]) >= zb0489 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025])[:zb0489]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] = make(applicationArgs, zb0470)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] = make(applicationArgs, zb0489)
}
- for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026], bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
if err != nil {
- err = msgp.WrapError(err, "ApplicationArgs", zb0024, zb0025)
+ err = msgp.WrapError(err, "ApplicationArgs", zb0025, zb0026)
return
}
}
}
case "apaabm":
{
- var zb0472 []byte
- var zb0473 int
- zb0473, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0491 []byte
+ var zb0492 int
+ zb0492, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- if zb0473 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0473), uint64(maxBitmaskSize))
+ if zb0492 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0492), uint64(maxBitmaskSize))
return
}
- zb0472, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
+ zb0491, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs))
if err != nil {
err = msgp.WrapError(err, "BitmaskApplicationArgs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0472)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs = bitmask(zb0491)
}
case "apat":
- var zb0474 int
- var zb0475 bool
- zb0474, zb0475, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0493 int
+ var zb0494 bool
+ zb0493, zb0494, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0474 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0474), uint64(maxEncodedTransactionGroups))
+ if zb0493 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0493), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Accounts")
return
}
- if zb0475 {
+ if zb0494 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0474 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0474]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) >= zb0493 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts)[:zb0493]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0474)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts = make([]addresses, zb0493)
}
- for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
- var zb0476 int
- var zb0477 bool
- zb0476, zb0477, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ var zb0495 int
+ var zb0496 bool
+ zb0495, zb0496, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0026)
+ err = msgp.WrapError(err, "Accounts", zb0027)
return
}
- if zb0476 > transactions.EncodedMaxAccounts {
- err = msgp.ErrOverflow(uint64(zb0476), uint64(transactions.EncodedMaxAccounts))
- err = msgp.WrapError(err, "Accounts", zb0026)
+ if zb0495 > transactions.EncodedMaxAccounts {
+ err = msgp.ErrOverflow(uint64(zb0495), uint64(transactions.EncodedMaxAccounts))
+ err = msgp.WrapError(err, "Accounts", zb0027)
return
}
- if zb0477 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026]) >= zb0476 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026])[:zb0476]
+ if zb0496 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027]) >= zb0495 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027])[:zb0495]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] = make(addresses, zb0476)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] = make(addresses, zb0495)
}
- for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].UnmarshalMsg(bts)
+ for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Accounts", zb0026, zb0027)
+ err = msgp.WrapError(err, "Accounts", zb0027, zb0028)
return
}
}
}
case "apatbm":
{
- var zb0478 []byte
- var zb0479 int
- zb0479, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0497 []byte
+ var zb0498 int
+ zb0498, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- if zb0479 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0479), uint64(maxBitmaskSize))
+ if zb0498 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0498), uint64(maxBitmaskSize))
return
}
- zb0478, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
+ zb0497, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts))
if err != nil {
err = msgp.WrapError(err, "BitmaskAccounts")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0478)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts = bitmask(zb0497)
}
case "apfa":
- var zb0480 int
- var zb0481 bool
- zb0480, zb0481, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0499 int
+ var zb0500 bool
+ zb0499, zb0500, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0480 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0480), uint64(maxEncodedTransactionGroups))
+ if zb0499 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0499), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignApps")
return
}
- if zb0481 {
+ if zb0500 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0480 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0480]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) >= zb0499 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps)[:zb0499]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0480)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps = make([]appIndices, zb0499)
}
- for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
- var zb0482 int
- var zb0483 bool
- zb0482, zb0483, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ var zb0501 int
+ var zb0502 bool
+ zb0501, zb0502, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0028)
+ err = msgp.WrapError(err, "ForeignApps", zb0029)
return
}
- if zb0482 > transactions.EncodedMaxForeignApps {
- err = msgp.ErrOverflow(uint64(zb0482), uint64(transactions.EncodedMaxForeignApps))
- err = msgp.WrapError(err, "ForeignApps", zb0028)
+ if zb0501 > transactions.EncodedMaxForeignApps {
+ err = msgp.ErrOverflow(uint64(zb0501), uint64(transactions.EncodedMaxForeignApps))
+ err = msgp.WrapError(err, "ForeignApps", zb0029)
return
}
- if zb0483 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028]) >= zb0482 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028])[:zb0482]
+ if zb0502 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029]) >= zb0501 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029])[:zb0501]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] = make(appIndices, zb0482)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] = make(appIndices, zb0501)
}
- for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].UnmarshalMsg(bts)
+ for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignApps", zb0028, zb0029)
+ err = msgp.WrapError(err, "ForeignApps", zb0029, zb0030)
return
}
}
}
case "apfabm":
{
- var zb0484 []byte
- var zb0485 int
- zb0485, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0503 []byte
+ var zb0504 int
+ zb0504, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- if zb0485 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0485), uint64(maxBitmaskSize))
+ if zb0504 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0504), uint64(maxBitmaskSize))
return
}
- zb0484, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
+ zb0503, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignApps")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0484)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps = bitmask(zb0503)
}
case "apas":
- var zb0486 int
- var zb0487 bool
- zb0486, zb0487, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0505 int
+ var zb0506 bool
+ zb0505, zb0506, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0486 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0486), uint64(maxEncodedTransactionGroups))
+ if zb0505 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0505), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ForeignAssets")
return
}
- if zb0487 {
+ if zb0506 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0486 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0486]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) >= zb0505 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets)[:zb0505]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0486)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets = make([]assetIndices, zb0505)
}
- for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
- var zb0488 int
- var zb0489 bool
- zb0488, zb0489, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ var zb0507 int
+ var zb0508 bool
+ zb0507, zb0508, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0030)
+ err = msgp.WrapError(err, "ForeignAssets", zb0031)
return
}
- if zb0488 > transactions.EncodedMaxForeignAssets {
- err = msgp.ErrOverflow(uint64(zb0488), uint64(transactions.EncodedMaxForeignAssets))
- err = msgp.WrapError(err, "ForeignAssets", zb0030)
+ if zb0507 > transactions.EncodedMaxForeignAssets {
+ err = msgp.ErrOverflow(uint64(zb0507), uint64(transactions.EncodedMaxForeignAssets))
+ err = msgp.WrapError(err, "ForeignAssets", zb0031)
return
}
- if zb0489 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030]) >= zb0488 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030])[:zb0488]
+ if zb0508 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031]) >= zb0507 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031])[:zb0507]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] = make(assetIndices, zb0488)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] = make(assetIndices, zb0507)
}
- for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].UnmarshalMsg(bts)
+ for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "ForeignAssets", zb0030, zb0031)
+ err = msgp.WrapError(err, "ForeignAssets", zb0031, zb0032)
return
}
}
}
case "apasbm":
{
- var zb0490 []byte
- var zb0491 int
- zb0491, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0509 []byte
+ var zb0510 int
+ zb0510, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- if zb0491 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0491), uint64(maxBitmaskSize))
+ if zb0510 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0510), uint64(maxBitmaskSize))
return
}
- zb0490, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
+ zb0509, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets))
if err != nil {
err = msgp.WrapError(err, "BitmaskForeignAssets")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0490)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets = bitmask(zb0509)
}
case "lnui":
- var zb0492 int
- var zb0493 bool
- zb0492, zb0493, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0511 int
+ var zb0512 bool
+ zb0511, zb0512, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0492 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0492), uint64(maxEncodedTransactionGroups))
+ if zb0511 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0511), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumUint")
return
}
- if zb0493 {
+ if zb0512 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0492 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0492]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) >= zb0511 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint)[:zb0511]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0492)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint = make([]uint64, zb0511)
}
- for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0032], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumUint", zb0032)
+ err = msgp.WrapError(err, "LocalNumUint", zb0033)
return
}
}
case "lnuibm":
{
- var zb0494 []byte
- var zb0495 int
- zb0495, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0513 []byte
+ var zb0514 int
+ zb0514, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- if zb0495 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0495), uint64(maxBitmaskSize))
+ if zb0514 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0514), uint64(maxBitmaskSize))
return
}
- zb0494, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
+ zb0513, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumUint")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0494)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint = bitmask(zb0513)
}
case "lnbs":
- var zb0496 int
- var zb0497 bool
- zb0496, zb0497, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0515 int
+ var zb0516 bool
+ zb0515, zb0516, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0496 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0496), uint64(maxEncodedTransactionGroups))
+ if zb0515 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0515), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "LocalNumByteSlice")
return
}
- if zb0497 {
+ if zb0516 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0496 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0496]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) >= zb0515 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice)[:zb0515]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0496)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice = make([]uint64, zb0515)
}
- for zb0033 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0033], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "LocalNumByteSlice", zb0033)
+ err = msgp.WrapError(err, "LocalNumByteSlice", zb0034)
return
}
}
case "lnbsbm":
{
- var zb0498 []byte
- var zb0499 int
- zb0499, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0517 []byte
+ var zb0518 int
+ zb0518, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- if zb0499 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0499), uint64(maxBitmaskSize))
+ if zb0518 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0518), uint64(maxBitmaskSize))
return
}
- zb0498, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
+ zb0517, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskLocalNumByteSlice")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0498)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice = bitmask(zb0517)
}
case "gnui":
- var zb0500 int
- var zb0501 bool
- zb0500, zb0501, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0519 int
+ var zb0520 bool
+ zb0519, zb0520, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0500 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0500), uint64(maxEncodedTransactionGroups))
+ if zb0519 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0519), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumUint")
return
}
- if zb0501 {
+ if zb0520 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0500 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0500]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) >= zb0519 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint)[:zb0519]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0500)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint = make([]uint64, zb0519)
}
- for zb0034 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0034], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumUint", zb0034)
+ err = msgp.WrapError(err, "GlobalNumUint", zb0035)
return
}
}
case "gnuibm":
{
- var zb0502 []byte
- var zb0503 int
- zb0503, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0521 []byte
+ var zb0522 int
+ zb0522, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- if zb0503 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0503), uint64(maxBitmaskSize))
+ if zb0522 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0522), uint64(maxBitmaskSize))
return
}
- zb0502, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
+ zb0521, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumUint")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0502)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint = bitmask(zb0521)
}
case "gnbs":
- var zb0504 int
- var zb0505 bool
- zb0504, zb0505, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0523 int
+ var zb0524 bool
+ zb0523, zb0524, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0504 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0504), uint64(maxEncodedTransactionGroups))
+ if zb0523 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0523), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "GlobalNumByteSlice")
return
}
- if zb0505 {
+ if zb0524 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0504 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0504]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) >= zb0523 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice)[:zb0523]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0504)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice = make([]uint64, zb0523)
}
- for zb0035 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0035], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice[zb0036], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "GlobalNumByteSlice", zb0035)
+ err = msgp.WrapError(err, "GlobalNumByteSlice", zb0036)
return
}
}
case "gnbsbm":
{
- var zb0506 []byte
- var zb0507 int
- zb0507, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0525 []byte
+ var zb0526 int
+ zb0526, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- if zb0507 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0507), uint64(maxBitmaskSize))
+ if zb0526 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0526), uint64(maxBitmaskSize))
return
}
- zb0506, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
+ zb0525, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice))
if err != nil {
err = msgp.WrapError(err, "BitmaskGlobalNumByteSlice")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0506)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice = bitmask(zb0525)
}
case "apap":
- var zb0508 int
- var zb0509 bool
- zb0508, zb0509, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0527 int
+ var zb0528 bool
+ zb0527, zb0528, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0508 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0508), uint64(maxEncodedTransactionGroups))
+ if zb0527 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0527), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ApprovalProgram")
return
}
- if zb0509 {
+ if zb0528 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0508 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0508]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) >= zb0527 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram)[:zb0527]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0508)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram = make([]program, zb0527)
}
- for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
{
- var zb0510 []byte
- var zb0511 int
- zb0511, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0529 []byte
+ var zb0530 int
+ zb0530, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0037)
return
}
- if zb0511 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0511), uint64(config.MaxAvailableAppProgramLen))
+ if zb0530 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0530), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0510, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ zb0529, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
if err != nil {
- err = msgp.WrapError(err, "ApprovalProgram", zb0036)
+ err = msgp.WrapError(err, "ApprovalProgram", zb0037)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036] = program(zb0510)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037] = program(zb0529)
}
}
case "apapbm":
{
- var zb0512 []byte
- var zb0513 int
- zb0513, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0531 []byte
+ var zb0532 int
+ zb0532, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- if zb0513 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0513), uint64(maxBitmaskSize))
+ if zb0532 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0532), uint64(maxBitmaskSize))
return
}
- zb0512, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
+ zb0531, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskApprovalProgram")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0512)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram = bitmask(zb0531)
}
case "apsu":
- var zb0514 int
- var zb0515 bool
- zb0514, zb0515, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0533 int
+ var zb0534 bool
+ zb0533, zb0534, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0514 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0514), uint64(maxEncodedTransactionGroups))
+ if zb0533 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0533), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ClearStateProgram")
return
}
- if zb0515 {
+ if zb0534 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0514 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0514]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) >= zb0533 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram)[:zb0533]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0514)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram = make([]program, zb0533)
}
- for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
{
- var zb0516 []byte
- var zb0517 int
- zb0517, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0535 []byte
+ var zb0536 int
+ zb0536, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0038)
return
}
- if zb0517 > config.MaxAvailableAppProgramLen {
- err = msgp.ErrOverflow(uint64(zb0517), uint64(config.MaxAvailableAppProgramLen))
+ if zb0536 > config.MaxAvailableAppProgramLen {
+ err = msgp.ErrOverflow(uint64(zb0536), uint64(config.MaxAvailableAppProgramLen))
return
}
- zb0516, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ zb0535, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
if err != nil {
- err = msgp.WrapError(err, "ClearStateProgram", zb0037)
+ err = msgp.WrapError(err, "ClearStateProgram", zb0038)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037] = program(zb0516)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038] = program(zb0535)
}
}
case "apsubm":
{
- var zb0518 []byte
- var zb0519 int
- zb0519, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0537 []byte
+ var zb0538 int
+ zb0538, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- if zb0519 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0519), uint64(maxBitmaskSize))
+ if zb0538 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0538), uint64(maxBitmaskSize))
return
}
- zb0518, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
+ zb0537, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram))
if err != nil {
err = msgp.WrapError(err, "BitmaskClearStateProgram")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0518)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram = bitmask(zb0537)
}
case "apep":
- var zb0520 int
- var zb0521 bool
- zb0520, zb0521, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0539 int
+ var zb0540 bool
+ zb0539, zb0540, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0520 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0520), uint64(maxEncodedTransactionGroups))
+ if zb0539 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0539), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "ExtraProgramPages")
return
}
- if zb0521 {
+ if zb0540 {
(*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0520 {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0520]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) >= zb0539 {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = ((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages)[:zb0539]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0520)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages = make([]uint32, zb0539)
}
- for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0038], bts, err = msgp.ReadUint32Bytes(bts)
+ for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages {
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages[zb0039], bts, err = msgp.ReadUint32Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "ExtraProgramPages", zb0038)
+ err = msgp.WrapError(err, "ExtraProgramPages", zb0039)
return
}
}
case "apepbm":
{
- var zb0522 []byte
- var zb0523 int
- zb0523, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0541 []byte
+ var zb0542 int
+ zb0542, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- if zb0523 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0523), uint64(maxBitmaskSize))
+ if zb0542 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0542), uint64(maxBitmaskSize))
return
}
- zb0522, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
+ zb0541, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages))
if err != nil {
err = msgp.WrapError(err, "BitmaskExtraProgramPages")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0522)
+ (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages = bitmask(zb0541)
}
case "certrnd":
- var zb0524 int
- var zb0525 bool
- zb0524, zb0525, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0543 int
+ var zb0544 bool
+ zb0543, zb0544, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0524 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0524), uint64(maxEncodedTransactionGroups))
+ if zb0543 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0543), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertRound")
return
}
- if zb0525 {
+ if zb0544 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0524 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0524]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) >= zb0543 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound)[:zb0543]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0524)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound = make([]basics.Round, zb0543)
}
- for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].UnmarshalMsg(bts)
+ for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertRound", zb0039)
+ err = msgp.WrapError(err, "CertRound", zb0040)
return
}
}
case "certrndbm":
{
- var zb0526 []byte
- var zb0527 int
- zb0527, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0545 []byte
+ var zb0546 int
+ zb0546, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- if zb0527 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0527), uint64(maxBitmaskSize))
+ if zb0546 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0546), uint64(maxBitmaskSize))
return
}
- zb0526, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
+ zb0545, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertRound")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0526)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound = bitmask(zb0545)
}
case "certtype":
- var zb0528 int
- var zb0529 bool
- zb0528, zb0529, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0547 int
+ var zb0548 bool
+ zb0547, zb0548, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "CertType")
return
}
- if zb0528 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0528), uint64(maxEncodedTransactionGroups))
+ if zb0547 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0547), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "CertType")
return
}
- if zb0529 {
+ if zb0548 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0528 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0528]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) >= zb0547 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType)[:zb0547]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0528)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType = make([]protocol.CompactCertType, zb0547)
}
- for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].UnmarshalMsg(bts)
+ for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "CertType", zb0040)
+ err = msgp.WrapError(err, "CertType", zb0041)
return
}
}
case "certtypebm":
{
- var zb0530 []byte
- var zb0531 int
- zb0531, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0549 []byte
+ var zb0550 int
+ zb0550, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- if zb0531 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0531), uint64(maxBitmaskSize))
+ if zb0550 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0550), uint64(maxBitmaskSize))
return
}
- zb0530, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
+ zb0549, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType))
if err != nil {
err = msgp.WrapError(err, "BitmaskCertType")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0530)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType = bitmask(zb0549)
}
case "certc":
- var zb0532 int
- zb0532, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0551 int
+ var zb0552 bool
+ zb0551, zb0552, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigCommit")
return
}
- if zb0532 > maxAddressBytes {
- err = msgp.ErrOverflow(uint64(zb0532), uint64(maxAddressBytes))
- return
- }
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit, bts, err = msgp.ReadBytesBytes(bts, (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)
- if err != nil {
+ if zb0551 > maxAddressBytes {
+ err = msgp.ErrOverflow(uint64(zb0551), uint64(maxAddressBytes))
err = msgp.WrapError(err, "SigCommit")
return
}
+ if zb0552 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) >= zb0551 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit)[:zb0551]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit = make([]crypto.GenericDigest, zb0551)
+ }
+ for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigCommit", zb0042)
+ return
+ }
+ }
case "certcbm":
{
- var zb0533 []byte
- var zb0534 int
- zb0534, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0553 []byte
+ var zb0554 int
+ zb0554, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- if zb0534 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0534), uint64(maxBitmaskSize))
+ if zb0554 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0554), uint64(maxBitmaskSize))
return
}
- zb0533, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
+ zb0553, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigCommit")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0533)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit = bitmask(zb0553)
}
case "certw":
- var zb0535 int
- var zb0536 bool
- zb0535, zb0536, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0555 int
+ var zb0556 bool
+ zb0555, zb0556, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0535 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0535), uint64(maxEncodedTransactionGroups))
+ if zb0555 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0555), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SignedWeight")
return
}
- if zb0536 {
+ if zb0556 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0535 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0535]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) >= zb0555 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight)[:zb0555]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0535)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight = make([]uint64, zb0555)
}
- for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0041], bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight[zb0043], bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SignedWeight", zb0041)
+ err = msgp.WrapError(err, "SignedWeight", zb0043)
return
}
}
case "certwbm":
{
- var zb0537 []byte
- var zb0538 int
- zb0538, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0557 []byte
+ var zb0558 int
+ zb0558, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- if zb0538 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0538), uint64(maxBitmaskSize))
+ if zb0558 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0558), uint64(maxBitmaskSize))
return
}
- zb0537, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
+ zb0557, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight))
if err != nil {
err = msgp.WrapError(err, "BitmaskSignedWeight")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0537)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight = bitmask(zb0557)
}
case "certS":
- var zb0539 int
- var zb0540 bool
- zb0539, zb0540, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0559 int
+ var zb0560 bool
+ zb0559, zb0560, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0539 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0539), uint64(maxEncodedTransactionGroups))
+ if zb0559 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0559), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "SigProofs")
return
}
- if zb0540 {
+ if zb0560 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0539 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0539]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) >= zb0559 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs)[:zb0559]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0539)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs = make([]certProofs, zb0559)
}
- for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
- var zb0541 int
- var zb0542 bool
- zb0541, zb0542, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ var zb0561 int
+ var zb0562 bool
+ zb0561, zb0562, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0042)
+ err = msgp.WrapError(err, "SigProofs", zb0044)
return
}
- if zb0541 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0541), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "SigProofs", zb0042)
+ if zb0561 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0561), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "SigProofs", zb0044)
return
}
- if zb0542 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042]) >= zb0541 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042])[:zb0541]
+ if zb0562 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044]) >= zb0561 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044])[:zb0561]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] = make(certProofs, zb0541)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] = make(certProofs, zb0561)
}
- for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].UnmarshalMsg(bts)
+ for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "SigProofs", zb0042, zb0043)
+ err = msgp.WrapError(err, "SigProofs", zb0044, zb0045)
return
}
}
}
case "certSbm":
{
- var zb0543 []byte
- var zb0544 int
- zb0544, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0563 []byte
+ var zb0564 int
+ zb0564, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- if zb0544 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0544), uint64(maxBitmaskSize))
+ if zb0564 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0564), uint64(maxBitmaskSize))
return
}
- zb0543, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
+ zb0563, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskSigProofs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0543)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs = bitmask(zb0563)
+ }
+ case "certSH":
+ var zb0565 int
+ var zb0566 bool
+ zb0565, zb0566, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0565 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0565), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "SigProofHashTypes")
+ return
+ }
+ if zb0566 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) >= zb0565 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes)[:zb0565]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes = make([]uint64, zb0565)
+ }
+ for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes[zb0046], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "SigProofHashTypes", zb0046)
+ return
+ }
+ }
+ case "certSHbm":
+ {
+ var zb0567 []byte
+ var zb0568 int
+ zb0568, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ if zb0568 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0568), uint64(maxBitmaskSize))
+ return
+ }
+ zb0567, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskSigsHash")
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash = bitmask(zb0567)
}
case "certP":
- var zb0545 int
- var zb0546 bool
- zb0545, zb0546, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0569 int
+ var zb0570 bool
+ zb0569, zb0570, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0545 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0545), uint64(maxEncodedTransactionGroups))
+ if zb0569 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0569), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "PartProofs")
return
}
- if zb0546 {
+ if zb0570 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0545 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0545]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) >= zb0569 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs)[:zb0569]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0545)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs = make([]certProofs, zb0569)
}
- for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
- var zb0547 int
- var zb0548 bool
- zb0547, zb0548, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for zb0047 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ var zb0571 int
+ var zb0572 bool
+ zb0571, zb0572, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0044)
+ err = msgp.WrapError(err, "PartProofs", zb0047)
return
}
- if zb0547 > compactcert.MaxProofDigests {
- err = msgp.ErrOverflow(uint64(zb0547), uint64(compactcert.MaxProofDigests))
- err = msgp.WrapError(err, "PartProofs", zb0044)
+ if zb0571 > compactcert.MaxProofDigests {
+ err = msgp.ErrOverflow(uint64(zb0571), uint64(compactcert.MaxProofDigests))
+ err = msgp.WrapError(err, "PartProofs", zb0047)
return
}
- if zb0548 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044]) >= zb0547 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044])[:zb0547]
+ if zb0572 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047]) >= zb0571 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047])[:zb0571]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] = make(certProofs, zb0547)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] = make(certProofs, zb0571)
}
- for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].UnmarshalMsg(bts)
+ for zb0048 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ bts, err = (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "PartProofs", zb0044, zb0045)
+ err = msgp.WrapError(err, "PartProofs", zb0047, zb0048)
return
}
}
}
case "certPbm":
{
- var zb0549 []byte
- var zb0550 int
- zb0550, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0573 []byte
+ var zb0574 int
+ zb0574, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- if zb0550 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0550), uint64(maxBitmaskSize))
+ if zb0574 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0574), uint64(maxBitmaskSize))
return
}
- zb0549, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
+ zb0573, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs))
if err != nil {
err = msgp.WrapError(err, "BitmaskPartProofs")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0549)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs = bitmask(zb0573)
+ }
+ case "certPH":
+ var zb0575 int
+ var zb0576 bool
+ zb0575, zb0576, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0575 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0575), uint64(maxEncodedTransactionGroups))
+ err = msgp.WrapError(err, "PartProofHashTypes")
+ return
+ }
+ if zb0576 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) >= zb0575 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes)[:zb0575]
+ } else {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes = make([]uint64, zb0575)
+ }
+ for zb0049 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes[zb0049], bts, err = msgp.ReadUint64Bytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "PartProofHashTypes", zb0049)
+ return
+ }
+ }
+ case "certPHbm":
+ {
+ var zb0577 []byte
+ var zb0578 int
+ zb0578, err = msgp.ReadBytesBytesHeader(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ if zb0578 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0578), uint64(maxBitmaskSize))
+ return
+ }
+ zb0577, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash))
+ if err != nil {
+ err = msgp.WrapError(err, "BitmaskPartHash")
+ return
+ }
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash = bitmask(zb0577)
}
case "certr":
- var zb0551 int
- var zb0552 bool
- zb0551, zb0552, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0579 int
+ var zb0580 bool
+ zb0579, zb0580, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0551 > maxEncodedTransactionGroups {
- err = msgp.ErrOverflow(uint64(zb0551), uint64(maxEncodedTransactionGroups))
+ if zb0579 > maxEncodedTransactionGroups {
+ err = msgp.ErrOverflow(uint64(zb0579), uint64(maxEncodedTransactionGroups))
err = msgp.WrapError(err, "Reveals")
return
}
- if zb0552 {
+ if zb0580 {
(*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0551 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0551]
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals != nil && cap((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) >= zb0579 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = ((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals)[:zb0579]
} else {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0551)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals = make([]revealMap, zb0579)
}
- for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
- var zb0553 int
- var zb0554 bool
- zb0553, zb0554, bts, err = msgp.ReadMapHeaderBytes(bts)
+ for zb0050 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ var zb0581 int
+ var zb0582 bool
+ zb0581, zb0582, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046)
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- if zb0553 > compactcert.MaxReveals {
- err = msgp.ErrOverflow(uint64(zb0553), uint64(compactcert.MaxReveals))
- err = msgp.WrapError(err, "Reveals", zb0046)
+ if zb0581 > compactcert.MaxReveals {
+ err = msgp.ErrOverflow(uint64(zb0581), uint64(compactcert.MaxReveals))
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- if zb0554 {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = nil
- } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] == nil {
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] = make(revealMap, zb0553)
+ if zb0582 {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = nil
+ } else if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] == nil {
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] = make(revealMap, zb0581)
}
- for zb0553 > 0 {
- var zb0047 uint64
- var zb0048 compactcert.Reveal
- zb0553--
- zb0047, bts, err = msgp.ReadUint64Bytes(bts)
+ for zb0581 > 0 {
+ var zb0051 uint64
+ var zb0052 compactcert.Reveal
+ zb0581--
+ zb0051, bts, err = msgp.ReadUint64Bytes(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046)
+ err = msgp.WrapError(err, "Reveals", zb0050)
return
}
- bts, err = zb0048.UnmarshalMsg(bts)
+ bts, err = zb0052.UnmarshalMsg(bts)
if err != nil {
- err = msgp.WrapError(err, "Reveals", zb0046, zb0047)
+ err = msgp.WrapError(err, "Reveals", zb0050, zb0051)
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046][zb0047] = zb0048
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050][zb0051] = zb0052
}
}
case "certrbm":
{
- var zb0555 []byte
- var zb0556 int
- zb0556, err = msgp.ReadBytesBytesHeader(bts)
+ var zb0583 []byte
+ var zb0584 int
+ zb0584, err = msgp.ReadBytesBytesHeader(bts)
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- if zb0556 > maxBitmaskSize {
- err = msgp.ErrOverflow(uint64(zb0556), uint64(maxBitmaskSize))
+ if zb0584 > maxBitmaskSize {
+ err = msgp.ErrOverflow(uint64(zb0584), uint64(maxBitmaskSize))
return
}
- zb0555, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
+ zb0583, bts, err = msgp.ReadBytesBytes(bts, []byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals))
if err != nil {
err = msgp.WrapError(err, "BitmaskReveals")
return
}
- (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0555)
+ (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals = bitmask(zb0583)
}
default:
err = msgp.ErrNoField(string(field))
@@ -35152,104 +37003,108 @@ func (z *txGroupsEncodingStub) Msgsize() (s int) {
for zb0011 := range (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast {
s += (*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast[zb0011].Msgsize()
}
- s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation)) + 4 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
- for zb0013 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
- s += (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0013].Msgsize()
+ s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys)) + 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot) * (msgp.BoolSize)) + 5 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot) + 4 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver) + 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver)) + 4 + msgp.ArrayHeaderSize
+ for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount[zb0014].Msgsize()
}
s += 6 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount)) + 6 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo)) + 5 + msgp.ArrayHeaderSize
- for zb0014 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
- s += (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0014].Msgsize()
+ for zb0015 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset[zb0015].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset)) + 2 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) * (msgp.Uint64Size)) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal)) + 3 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) * (msgp.Uint32Size)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals)) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen)) + 3 + msgp.ArrayHeaderSize
- for zb0017 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
- s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0017])
+ for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName {
+ s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName[zb0018])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName)) + 3 + msgp.ArrayHeaderSize
- for zb0018 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
- s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0018])
+ for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName {
+ s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName[zb0019])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName)) + 3 + msgp.ArrayHeaderSize
- for zb0019 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
- s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0019])
+ for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL {
+ s += msgp.StringPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL[zb0020])
}
s += 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL)) + 3 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) + 5 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash)) + 2 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager)) + 2 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve)) + 2 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze)) + 2 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) + 4 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback)) + 5 + msgp.ArrayHeaderSize
- for zb0020 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
- s += (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0020].Msgsize()
+ for zb0021 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset[zb0021].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount)) + 5 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender)) + 5 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver)) + 7 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo)) + 5 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount)) + 5 + msgp.ArrayHeaderSize
- for zb0022 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
- s += (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0022].Msgsize()
+ for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset[zb0023].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen)) + 5 + msgp.ArrayHeaderSize
- for zb0023 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
- s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0023].Msgsize()
+ for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID[zb0024].Msgsize()
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID)) + 5 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion)) + 5 + msgp.ArrayHeaderSize
- for zb0024 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
+ for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs {
s += msgp.ArrayHeaderSize
- for zb0025 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024] {
- s += msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0024][zb0025])
+ for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025] {
+ s += msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs[zb0025][zb0026])
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs)) + 5 + msgp.ArrayHeaderSize
- for zb0026 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
+ for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts {
s += msgp.ArrayHeaderSize
- for zb0027 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026] {
- s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0026][zb0027].Msgsize()
+ for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027] {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts[zb0027][zb0028].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts)) + 5 + msgp.ArrayHeaderSize
- for zb0028 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
+ for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps {
s += msgp.ArrayHeaderSize
- for zb0029 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028] {
- s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0028][zb0029].Msgsize()
+ for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029] {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps[zb0029][zb0030].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps)) + 5 + msgp.ArrayHeaderSize
- for zb0030 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
+ for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets {
s += msgp.ArrayHeaderSize
- for zb0031 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030] {
- s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0030][zb0031].Msgsize()
+ for zb0032 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031] {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets[zb0031][zb0032].Msgsize()
}
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) * (msgp.Uint64Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice)) + 5 + msgp.ArrayHeaderSize
- for zb0036 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0036]))
+ for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram[zb0037]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram)) + 5 + msgp.ArrayHeaderSize
- for zb0037 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
- s += msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0037]))
+ for zb0038 := range (*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram {
+ s += msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram[zb0038]))
}
s += 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram)) + 5 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) * (msgp.Uint32Size)) + 7 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages)) + 8 + msgp.ArrayHeaderSize
- for zb0039 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
- s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0039].Msgsize()
+ for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound[zb0040].Msgsize()
}
s += 10 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound)) + 9 + msgp.ArrayHeaderSize
- for zb0040 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
- s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0040].Msgsize()
+ for zb0041 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType[zb0041].Msgsize()
}
- s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.BytesPrefixSize + len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
- for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
+ s += 11 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType)) + 6 + msgp.ArrayHeaderSize
+ for zb0042 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit[zb0042].Msgsize()
+ }
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit)) + 6 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) * (msgp.Uint64Size)) + 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight)) + 6 + msgp.ArrayHeaderSize
+ for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs {
s += msgp.ArrayHeaderSize
- for zb0043 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042] {
- s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0042][zb0043].Msgsize()
+ for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044] {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs[zb0044][zb0045].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0044 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0047 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs {
s += msgp.ArrayHeaderSize
- for zb0045 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044] {
- s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0044][zb0045].Msgsize()
+ for zb0048 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047] {
+ s += (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs[zb0047][zb0048].Msgsize()
}
}
- s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 6 + msgp.ArrayHeaderSize
- for zb0046 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
+ s += 8 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs)) + 7 + msgp.ArrayHeaderSize + (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) * (msgp.Uint64Size)) + 9 + msgp.BytesPrefixSize + len([]byte((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash)) + 6 + msgp.ArrayHeaderSize
+ for zb0050 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals {
s += msgp.MapHeaderSize
- if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] != nil {
- for zb0047, zb0048 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0046] {
- _ = zb0047
- _ = zb0048
- s += 0 + msgp.Uint64Size + zb0048.Msgsize()
+ if (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] != nil {
+ for zb0051, zb0052 := range (*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals[zb0050] {
+ _ = zb0051
+ _ = zb0052
+ s += 0 + msgp.Uint64Size + zb0052.Msgsize()
}
}
}
@@ -35259,7 +37114,7 @@ func (z *txGroupsEncodingStub) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *txGroupsEncodingStub) MsgIsZero() bool {
- return ((*z).TotalTransactionsCount == 0) && ((*z).TransactionGroupCount == 0) && (len((*z).TransactionGroupSizes) == 0) && (len((*z).encodedSignedTxns.Sig) == 0) && (len((*z).encodedSignedTxns.BitmaskSig) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Version) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Threshold) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Subsigs) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.Logic) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.LogicArgs) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs) == 0) && (len((*z).encodedSignedTxns.AuthAddr) == 0) && (len((*z).encodedSignedTxns.BitmaskAuthAddr) == 0) && (len((*z).encodedSignedTxns.encodedTxns.TxType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.BitmaskTxType) == 0) && ((*z).encodedSignedTxns.encodedTxns.TxTypeOffset == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
+ return ((*z).TotalTransactionsCount == 0) && ((*z).TransactionGroupCount == 0) && (len((*z).TransactionGroupSizes) == 0) && (len((*z).encodedSignedTxns.Sig) == 0) && (len((*z).encodedSignedTxns.BitmaskSig) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Version) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskVersion) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Threshold) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskThreshold) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.Subsigs) == 0) && (len((*z).encodedSignedTxns.encodedMsigs.BitmaskSubsigs) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.Logic) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogic) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.LogicArgs) == 0) && (len((*z).encodedSignedTxns.encodedLsigs.BitmaskLogicArgs) == 0) && (len((*z).encodedSignedTxns.AuthAddr) == 0) && (len((*z).encodedSignedTxns.BitmaskAuthAddr) == 0) && (len((*z).encodedSignedTxns.encodedTxns.TxType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.BitmaskTxType) == 0) && ((*z).encodedSignedTxns.encodedTxns.TxTypeOffset == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Sender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Fee) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFee) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.FirstValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskFirstValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.LastValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLastValid) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Note) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskNote) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGenesisID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskGroup) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.Lease) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskLease) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.RekeyTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedTxnHeaders.BitmaskRekeyTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VotePK) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.SelectionPK) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteFirst) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteFirst) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteLast) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskVoteLast) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.VoteKeyDilution) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskKeys) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.BitmaskNonparticipation) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.HasValidRoot) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedKeyregTxnFields.CommitmentRoot) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Receiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.Amount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.CloseRemainderTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedPaymentTxnFields.BitmaskCloseRemainderTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.ConfigAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.BitmaskConfigAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Total) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskTotal) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Decimals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDecimals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskDefaultFrozen) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.UnitName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskUnitName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.AssetName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskAssetName) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.URL) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskURL) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.MetadataHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskMetadataHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Manager) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskManager) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Reserve) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskReserve) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Freeze) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskFreeze) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.Clawback) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetConfigTxnFields.encodedAssetParams.BitmaskClawback) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.XferAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskXferAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetAmount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetSender) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetReceiver) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.AssetCloseTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetTransferTxnFields.BitmaskAssetCloseTo) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAccount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAccount) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.FreezeAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskFreezeAsset) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedAssetFreezeTxnFields.BitmaskAssetFrozen) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationID) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.OnCompletion) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskOnCompletion) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApplicationArgs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApplicationArgs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.Accounts) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskAccounts) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignApps) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignApps) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ForeignAssets) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskForeignAssets) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.LocalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskLocalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumUint) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.GlobalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskGlobalNumByteSlice) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ApprovalProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskApprovalProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ClearStateProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskClearStateProgram) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.ExtraProgramPages) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedApplicationCallTxnFields.BitmaskExtraProgramPages) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertRound) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertRound) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.CertType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.BitmaskCertType) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigCommit) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigCommit) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SignedWeight) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSignedWeight) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.SigProofHashTypes) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskSigsHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartProofs) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.PartProofHashTypes) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskPartHash) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.Reveals) == 0) && (len((*z).encodedSignedTxns.encodedTxns.encodedCompactCertTxnFields.encodedCert.BitmaskReveals) == 0)
}
// MarshalMsg implements msgp.Marshaler
diff --git a/txnsync/txngroups_test.go b/txnsync/txngroups_test.go
index 6306494f3..013637221 100644
--- a/txnsync/txngroups_test.go
+++ b/txnsync/txngroups_test.go
@@ -94,7 +94,7 @@ func TestTxnGroupEncodingSmall(t *testing.T) {
genesisID := "gID"
inTxnGroups := []pooldata.SignedTxGroup{
- pooldata.SignedTxGroup{
+ {
Transactions: []transactions.SignedTxn{
{
Txn: transactions.Transaction{
@@ -113,7 +113,7 @@ func TestTxnGroupEncodingSmall(t *testing.T) {
},
},
},
- pooldata.SignedTxGroup{
+ {
Transactions: []transactions.SignedTxn{
{
Txn: transactions.Transaction{
@@ -144,7 +144,7 @@ func TestTxnGroupEncodingSmall(t *testing.T) {
},
},
},
- pooldata.SignedTxGroup{
+ {
Transactions: []transactions.SignedTxn{
{
Txn: transactions.Transaction{
@@ -455,11 +455,11 @@ func TestTxnGroupEncodingReflection(t *testing.T) {
txn.Txn.ApplicationCallTxnFields = *ApplicationCallTxnFields
txn.Txn.ApplicationCallTxnFields.OnCompletion = 1
case protocol.CompactCertTx:
- v0, err := protocol.RandomizeObject(&txn.Txn.CompactCertTxnFields)
- require.NoError(t, err)
- CompactCertTxnFields, ok := v0.(*transactions.CompactCertTxnFields)
- require.True(t, ok)
- txn.Txn.CompactCertTxnFields = *CompactCertTxnFields
+ //v0, err := protocol.RandomizeObject(&txn.Txn.CompactCertTxnFields)
+ //require.NoError(t, err)
+ //CompactCertTxnFields, ok := v0.(*transactions.CompactCertTxnFields)
+ //require.True(t, ok)
+ //txn.Txn.CompactCertTxnFields = *CompactCertTxnFields
default:
require.Fail(t, "unsupported txntype for txnsync msg encoding")
}
@@ -467,7 +467,7 @@ func TestTxnGroupEncodingReflection(t *testing.T) {
txns = append(txns, txn)
}
txnGroups := []pooldata.SignedTxGroup{
- pooldata.SignedTxGroup{
+ {
Transactions: txns,
},
}
generated by cgit v1.2.3 (git 2.44.0) at 2024-04-30 18:25:20 +0000