From 249016cf51cf9c3aecf37c6fc8c09774523f02bc Mon Sep 17 00:00:00 2001 From: Gary Malouf <982483+gmalouf@users.noreply.github.com> Date: Fri, 13 Sep 2024 11:11:01 -0400 Subject: [PATCH 1/9] Disable rewinding and reject the query param on account lookups and searches. (#1630) --- accounting/rewind.go | 188 -------------- accounting/rewind_test.go | 79 ------ api/error_messages.go | 3 +- api/generated/v2/routes.go | 447 ++++++++++++++++----------------- api/generated/v2/types.go | 4 +- api/handlers.go | 50 +--- api/handlers_test.go | 82 +++--- api/indexer.oas2.json | 8 +- api/indexer.oas3.yml | 4 +- api/server.go | 16 +- cmd/algorand-indexer/daemon.go | 3 +- cmd/idbtest/idbtest.go | 4 - 12 files changed, 298 insertions(+), 590 deletions(-) delete mode 100644 accounting/rewind.go delete mode 100644 accounting/rewind_test.go diff --git a/accounting/rewind.go b/accounting/rewind.go deleted file mode 100644 index cfc6cdcf7..000000000 --- a/accounting/rewind.go +++ /dev/null @@ -1,188 +0,0 @@ -package accounting - -import ( - "context" - "fmt" - - models "github.com/algorand/indexer/v3/api/generated/v2" - "github.com/algorand/indexer/v3/idb" - "github.com/algorand/indexer/v3/types" - - sdk "github.com/algorand/go-algorand-sdk/v2/types" -) - -// ConsistencyError is returned when the database returns inconsistent (stale) results. -type ConsistencyError struct { - msg string -} - -func (e ConsistencyError) Error() string { - return e.msg -} - -func assetUpdate(account *models.Account, assetid uint64, add, sub uint64) { - if account.Assets == nil { - account.Assets = new([]models.AssetHolding) - } - assets := *account.Assets - for i, ah := range assets { - if ah.AssetId == assetid { - ah.Amount += add - ah.Amount -= sub - assets[i] = ah - // found and updated asset, done - return - } - } - // add asset to list - assets = append(assets, models.AssetHolding{ - Amount: add - sub, - AssetId: assetid, - //Creator: base32 addr string of asset creator, TODO - //IsFrozen: leave nil? // TODO: on close record frozen state for rewind - }) - *account.Assets = assets -} - -// SpecialAccountRewindError indicates that an attempt was made to rewind one of the special accounts. -type SpecialAccountRewindError struct { - account string -} - -// MakeSpecialAccountRewindError helper to initialize a SpecialAccountRewindError. -func MakeSpecialAccountRewindError(account string) *SpecialAccountRewindError { - return &SpecialAccountRewindError{account: account} -} - -// Error is part of the error interface. -func (sare *SpecialAccountRewindError) Error() string { - return fmt.Sprintf("unable to rewind the %s", sare.account) -} - -var specialAccounts *types.SpecialAddresses - -// AccountAtRound queries the idb.IndexerDb object for transactions and rewinds most fields of the account back to -// their values at the requested round. -// `round` must be <= `account.Round` -func AccountAtRound(ctx context.Context, account models.Account, round uint64, db idb.IndexerDb) (acct models.Account, err error) { - // Make sure special accounts cache has been initialized. - if specialAccounts == nil { - var accounts types.SpecialAddresses - accounts, err = db.GetSpecialAccounts(ctx) - if err != nil { - return models.Account{}, fmt.Errorf("unable to get special accounts: %v", err) - } - specialAccounts = &accounts - } - - acct = account - var addr sdk.Address - addr, err = sdk.DecodeAddress(account.Address) - if err != nil { - return - } - - // ensure that the don't attempt to rewind a special account. - if specialAccounts.FeeSink == addr { - err = MakeSpecialAccountRewindError("FeeSink") - return - } - if specialAccounts.RewardsPool == addr { - err = MakeSpecialAccountRewindError("RewardsPool") - return - } - - // Get transactions and rewind account. - tf := idb.TransactionFilter{ - Address: addr[:], - MinRound: round + 1, - MaxRound: account.Round, - } - ctx2, cf := context.WithCancel(ctx) - // In case of a panic before the next defer, call cf() here. - defer cf() - txns, r := db.Transactions(ctx2, tf) - // In case of an error, make sure the context is cancelled, and the channel is cleaned up. - defer func() { - cf() - for range txns { - } - }() - if r < account.Round { - err = ConsistencyError{fmt.Sprintf("queried round r: %d < account.Round: %d", r, account.Round)} - return - } - txcount := 0 - for txnrow := range txns { - if txnrow.Error != nil { - err = txnrow.Error - return - } - txcount++ - stxn := txnrow.Txn - if stxn == nil { - return models.Account{}, - fmt.Errorf("rewinding past inner transactions is not supported") - } - if addr == stxn.Txn.Sender { - acct.AmountWithoutPendingRewards += uint64(stxn.Txn.Fee) - acct.AmountWithoutPendingRewards -= uint64(stxn.SenderRewards) - } - switch stxn.Txn.Type { - case sdk.PaymentTx: - if addr == stxn.Txn.Sender { - acct.AmountWithoutPendingRewards += uint64(stxn.Txn.Amount) - } - if addr == stxn.Txn.Receiver { - acct.AmountWithoutPendingRewards -= uint64(stxn.Txn.Amount) - acct.AmountWithoutPendingRewards -= uint64(stxn.ReceiverRewards) - } - if addr == stxn.Txn.CloseRemainderTo { - // unwind receiving a close-to - acct.AmountWithoutPendingRewards -= uint64(stxn.ClosingAmount) - acct.AmountWithoutPendingRewards -= uint64(stxn.CloseRewards) - } else if !stxn.Txn.CloseRemainderTo.IsZero() { - // unwind sending a close-to - acct.AmountWithoutPendingRewards += uint64(stxn.ClosingAmount) - } - case sdk.KeyRegistrationTx: - // TODO: keyreg does not rewind. workaround: query for txns on an account with typeenum=2 to find previous values it was set to. - case sdk.AssetConfigTx: - if stxn.Txn.ConfigAsset == 0 { - // create asset, unwind the application of the value - assetUpdate(&acct, txnrow.AssetID, 0, stxn.Txn.AssetParams.Total) - } - case sdk.AssetTransferTx: - if addr == stxn.Txn.AssetSender || addr == stxn.Txn.Sender { - assetUpdate(&acct, uint64(stxn.Txn.XferAsset), stxn.Txn.AssetAmount+txnrow.Extra.AssetCloseAmount, 0) - } - if addr == stxn.Txn.AssetReceiver { - assetUpdate(&acct, uint64(stxn.Txn.XferAsset), 0, stxn.Txn.AssetAmount) - } - if addr == stxn.Txn.AssetCloseTo { - assetUpdate(&acct, uint64(stxn.Txn.XferAsset), 0, txnrow.Extra.AssetCloseAmount) - } - case sdk.AssetFreezeTx: - default: - err = fmt.Errorf("%s[%d,%d]: rewinding past txn type %s is not currently supported", account.Address, txnrow.Round, txnrow.Intra, stxn.Txn.Type) - return - } - } - - acct.Round = round - - // Due to accounts being closed and re-opened, we cannot always rewind Rewards. So clear it out. - acct.Rewards = 0 - - // Computing pending rewards is not supported. - acct.PendingRewards = 0 - acct.Amount = acct.AmountWithoutPendingRewards - - // MinBalance is not supported. - acct.MinBalance = 0 - - // TODO: Clear out the closed-at field as well. Like Rewards we cannot know this value for all accounts. - //acct.ClosedAt = 0 - - return -} diff --git a/accounting/rewind_test.go b/accounting/rewind_test.go deleted file mode 100644 index caa77a960..000000000 --- a/accounting/rewind_test.go +++ /dev/null @@ -1,79 +0,0 @@ -package accounting - -import ( - "context" - "errors" - "testing" - - sdk "github.com/algorand/go-algorand-sdk/v2/types" - "github.com/algorand/indexer/v3/types" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" - - models "github.com/algorand/indexer/v3/api/generated/v2" - "github.com/algorand/indexer/v3/idb" - "github.com/algorand/indexer/v3/idb/mocks" -) - -func TestBasic(t *testing.T) { - var a sdk.Address - a[0] = 'a' - - account := models.Account{ - Address: a.String(), - Amount: 100, - AmountWithoutPendingRewards: 100, - Round: 8, - } - - txnRow := idb.TxnRow{ - Round: 7, - Txn: &sdk.SignedTxnWithAD{ - SignedTxn: sdk.SignedTxn{ - Txn: sdk.Transaction{ - Type: sdk.PaymentTx, - PaymentTxnFields: sdk.PaymentTxnFields{ - Receiver: a, - Amount: sdk.MicroAlgos(2), - }, - }, - }, - }, - } - - ch := make(chan idb.TxnRow, 1) - ch <- txnRow - close(ch) - var outCh <-chan idb.TxnRow = ch - - db := &mocks.IndexerDb{} - db.On("GetSpecialAccounts", mock.Anything).Return(types.SpecialAddresses{}, nil) - db.On("Transactions", mock.Anything, mock.Anything).Return(outCh, uint64(8)) - - account, err := AccountAtRound(context.Background(), account, 6, db) - assert.NoError(t, err) - - assert.Equal(t, uint64(98), account.Amount) -} - -// Test that when idb.Transactions() returns stale data the first time, we return an error. -func TestStaleTransactions1(t *testing.T) { - var a sdk.Address - a[0] = 'a' - - account := models.Account{ - Address: a.String(), - Round: 8, - } - - ch := make(chan idb.TxnRow) - var outCh <-chan idb.TxnRow = ch - close(ch) - - db := &mocks.IndexerDb{} - db.On("GetSpecialAccounts", mock.Anything).Return(types.SpecialAddresses{}, nil) - db.On("Transactions", mock.Anything, mock.Anything).Return(outCh, uint64(7)).Once() - - account, err := AccountAtRound(context.Background(), account, 6, db) - assert.True(t, errors.As(err, &ConsistencyError{}), "err: %v", err) -} diff --git a/api/error_messages.go b/api/error_messages.go index d9c339ada..a1bfbfbc2 100644 --- a/api/error_messages.go +++ b/api/error_messages.go @@ -36,8 +36,7 @@ const ( errMultipleApplications = "multiple applications found for this id, please contact us, this shouldn't happen" ErrMultipleBoxes = "multiple application boxes found for this app id and box name, please contact us, this shouldn't happen" ErrFailedLookingUpBoxes = "failed while looking up application boxes" - errMultiAcctRewind = "multiple accounts rewind is not supported by this server" - errRewindingAccount = "error while rewinding account" + errRewindingAccountNotSupported = "rewinding account is no longer supported, please remove the `round=` query parameter and try again" errLookingUpBlockForRound = "error while looking up block for round" errTransactionSearch = "error while searching for transaction" errZeroAddressCloseRemainderToRole = "searching transactions by zero address with close address role is not supported" diff --git a/api/generated/v2/routes.go b/api/generated/v2/routes.go index 14159f619..6b9f38d0d 100644 --- a/api/generated/v2/routes.go +++ b/api/generated/v2/routes.go @@ -1212,230 +1212,229 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9e3MbN5Yo/lVQ/G2V7fzYkuM8akdVqS0/xjeusTMu28nsrpV7B+wGSYyaQAdAS2Ry", - "/d1v4RwAje5Gk02JkuUN/7LFxuMAODg47/PHJJerSgomjJ6c/TGpqKIrZpiCv2iey1qYjBf2r4LpXPHK", - "cCkmZ/4b0UZxsZhMJ9z+WlGznEwngq5Y08b2n04U+63mihWTM6NqNp3ofMlW1A5sNpVt7Ub69Gk6oUWh", - "mNb9Wf8uyg3hIi/rghGjqNA0t580ueJmScySa+I6Ey6IFIzIOTHLVmMy56ws9IkH+reaqU0EtZt8GMTp", - "ZJ3RciEVFUU2l2pFzeRs8tT1+7Tzs5shU7Jk/TU+l6sZF8yviIUFhcMhRpKCzaHRkhpiobPr9A2NJJpR", - "lS/JXKody0Qg4rUyUa8mZx8nmomCKTi5nPFL+O9cMfY7ywxVC2Ymv05TZzc3TGWGrxJLe+VOTjFdl0YT", - "aAtrXPBLJojtdULe1NqQGSNUkHcvn5NvvvnmLwS30bDCIdzgqprZ4zWFUyioYf7zmEN99/I5zP/eLXBs", - "K1pVJc+pXXfy+jxtvpNXL4YW0x4kgZBcGLZgCjdea5a+q0/tly3T+I67JqjNMrNoM3yw7sZrkksx54ta", - "scJiY60Z3k1dMVFwsSAXbDN4hGGa27uBMzaXio3EUmx8UDSN5/+seDqT6wxh6iENmck1sd8sJV1IWmZU", - "LWCF5AETubTneHZJy5o9OCEvpSJcGD11Z81cQy7M2ddPvvnWNVH0isw2hvXazb7/9uzpDz+4ZpXiwtBZ", - "ydw29ppro86WrCyl6+CIWX9c++HsP//rv09OTh4MHQb8s98DlddKMZFvsoViFCjOkor+Hr5zGKSXsi4L", - "sqSXgC50BU+n60tsX7wesJsn5A3PlXxaLqQm1CFewea0Lg3xE5NalJbU29Hc9SVck0rJS16wYmrP7GrJ", - "8yXJqdsQaEeueFlarK01K4Y2JL26HdQhdLJwXWs/YEH3dzOade3YCbYG+tFf/l/XjkoWBbc/0ZJww1aa", - "6DpfEqodVEtZFoj00QNASpnTkhTUUKKNtIR1LpXjeJDqTl3/hokjORxgQWabbktRtEbf3cfuD1tXpbQr", - "m9NSs/R++dXHmwSrjHkLWpYT92JZRstNmYUfaFXpDFacaUMNi9tUlW0hpGAJBiT8QJWiG/u3NhvLZQFp", - "nTSnk+Wl1CwzcgcD5nkq2LCIZYp3bC92jHxYMgKT2w/IigJmC0uly3JDjDsAixDEM19TwudkI2tyBVen", - "5BfQ363G4vSK2MOHI2txipaaDSF3bzMSqD2TsmRUAGovGS2YyqQoN/19+xE+EvuRzEu6OCH/WDJ3me3b", - "b6FDcKZEMVMrYbGslPkFKSTTREhj+QZDueiy7HoA/hieHaA7qSGzqDfMv5T+SmJzy6rA3hSBtZmSgpUM", - "zqe5P/CrNkpu4NwsFk+JrCy+ytr077Uo3LD4uXvNAecHBZR4JTsWXfIVN/3lvqFrvqpXRNSrmT2xeeB1", - "jHRHA3iqGMkB3WYtolXRBdOEWVaIo3QF89hDtmeoGM2XwwQVYdpBQ1d0nSlZi2KEEGGIVDGTpiuW8zln", - "BQmjDMHSTLMLHi72g6cRbSJw/CCD4IRZdoAj2DpxrJay2C9wQNGpnpCf3bMHX428YCK8jkjnGakUu+Sy", - "1qHTELdkp97OHQlpWFYpNufrPpDv3XZY4oZt3Nu8cvy0IwGsII4O2OGQUA7CFE24r9Awo5p9/+0Qx9x8", - "VeyCbZLvRRcBcDlBS7G0X7Dv9lWEGXZc6pF4iOxBjH9bcW8U3kGjDMlGgr2zXx1RSWuEWv1HsNzx3KiP", - "yG6kG8Ix/Ms8tBWdmW5PDNV8keGIvVvCFx8sGzHnJbAY/7KXw59sre271D5bz3RovhDU1IqdnYuv7F8k", - "I+8NFQVVhf1lhT+9qUvD3/OF/anEn17LBc/f88XQpnhYk7oi6LbCf+x4ad2QWYflpqbwn1MzVNQ2vGAb", - "xewcNJ/DP+s5IBKdq9+RbYQn0VTzIQBS+pHXUl7UVbyheUtfONuQVy+GkAWG3EYPgXboSgrNAGufIiPx", - "zv1mf7Ikjwmg6BEvcPovLUGIasaulKyYMpzF+ln7339TbD45m/x/p40+9xS76VM34SQIaWboKcMLTI0j", - "YUi6HFFDZmBV1Qaf9hR1CNf5Y4CtO2dzLHL2L5Yb3KA2GA/ZqjKbRxZgB7s+3G7plkAyct+6QsUt7iM+", - "7hk80v2Rf9ZO8KvoggtY+JRcWTZ7RS8sVaBCmiVTxJ4F08Y/80j+8OUPimXHKzhZ4WSSujGJM9U3PtTm", - "1F5bdvc9sLuHOOKO2LjHWadAOp58OPnexh4SBRYHOvutGvfz84+0qnixPj//tSVxcVGwdfo8bvWwS7nI", - "Cmro9XB08cJ2TSDofcahtjXjUAh0WOTZ4xTu9kU91HYd+LJdi8YeKWviVtycqGrNzDNaUpEf5DmduaFG", - "n/AbLjgA8SOquo7H7I85bOUhjtjt7kEuMmrcR1/h4+Gm7nCwY9z4aA91pKMO8o4lQpjyEJv0uRD/iPGH", - "xfhnpcwvrnWW244KRt01s1wffl65Ts36TK4JF6j9c5zPM7lm91XkmVnYRl+LZ3L9wk0p1ZctjeDCx2Dw", - "M+cXo8HIK+KdtUv+q1JSHeB0vWzYgWc6WTGt6YKlbS/xGn3DMYvyAMOBMLsE0FD/yGhpls+X7BYuajT2", - "juv6oVHGHmBjb5VkR3rjXeuPVrVD2GsPuyeVjabR93337g+5aG35eILYOtMuORx/xnq/Q/7k7Q+xgSHh", - "0ud8tqPnyJ4UdW6NaB48F+fiBZtzAdb+s3Nh6dDpjGqe69NaM+UEzJOFJGfEDfmCGnouJtPuAzVkqwMX", - "LAdNVc9KnpMLtkmdAvqGJUaQhpaRA0PkJubMxo0Foo9nOGpm0UHWJnNeqZliV1QVCXh1MFrDyOivtm3W", - "KXFjo23deb268dO43/N56vvcb3UH46Ltr2UP8idpnAWaXhFEJFJrpsk/V7T6yIX5lWTn9ePH3zDytKoa", - "zfc/G+cyCyjYvg6qRofFwhlmbG0UzcCnJI0oul7BS1uWBNq2HdeUXCi6cj4pXZe4LTuNk497qaJlwYre", - "Y69P00iM6BwV/E6WrOw70u17MJHMfe1z2SG3b3Ht/hBFINAF5UJ72q75Qlisdt6cM0Zy+5az4oS8mhOg", - "TdNWAIMLxXB0LxAArtEBk3yw6wIXCZJTAY6ZVQGucFwQKjZdo6xmxnhL+Dt2wTYfIg+LPS31zh2L7njY", - "itoOFx635lTJFdVkJcFKnzNhyo3z8EqgYBqYmguDriYtV8ceIJHjob0Vkf5wyHUzcmajVUUWpZw52hFw", - "8Swgo+8zTCbeWgD0AUhEUp5uu4LuWj1esyGX1f1XZ8e70SXbuqZrI9ecKw1+gow6Uk/jy3ANHHNOjH1Q", - "/rFkwEVJBc58bTzS/vKm0Dv4KIGzJROGX7KMlXzBZ6k4p5y2Xkzv6eo8QsMImvA54UYTp0K1QHBBFBUL", - "ZrkXy3FITUuMykhCU1JtsiWjyswYHfCbg4NpHMVby7b9yZUlWVKUXLCp3Ry2tnjM7U4oJtgVK+xquHJt", - "iH3D64GnHgBCwFNHMAoe3x32EPYsPdeKi8xtXcIR1PMvYXc9g+rdAuOrBHDh9xWDAAZ5Zc/FQiGd733P", - "s7y2ImgatIoqw3NejbO7ISBvW33sILt4tyS3JuddpqzHPyVBxsaZXXN/plqj17Zdl3/s/Ogo9wDUJwRc", - "1dwmzUpw5A6RU3jeVIGHuV8qRhINgaOH2GM/eXvt8aVbUu0vHsRJ+HdiFMc6QMwa9LV0NMLfWO7gdt6S", - "XdKhnR72jQPf8K67G7AQ/TgH71SKkaDeJ847wnnvN/uvpXd1WVpqU4sLIa+sOLOPf9t0gle+D/ClBDYF", - "P3vEcCA+0NHRWDj+Pp8D/cgIF4W9RCB0UOPDVmTOMTqgocmWli/sjyd2AItddoDRI6TQ1g0JHLaUJQ5M", - "fpLx/ROLfYAUjMO7Qv3Y8MBEf7O0FA5sOnDs6E/PRRrjcn/LrZzQ4ooAMIg1mjEm0C2fcDEllpRd0tKS", - "MiORNQ2DpEWthy0pyTHu+tGQCJbWEOGKgHPZa03I61xnNTH774FOyyZbIJ7JdQaxe31YIQSvqrJAxKQo", - "Nxjp0pXTYQS7HpkDhngv5Qu2wSAbCPuCWwIaWUc/ZqyUltOXPQxrDmoH8DcF/IDQbGfwU9isAfWQ827Q", - "bkuo1s6pB/jrIbR7CDh0AwC6+vfgXO00PDuVMm1Wpv/wN6/htHFmR4qcJiNDV7GP8G0sSp7iwP721XjB", - "p/Vtl/tJKutarQg2mTk9VCQLpV4/S45yKTQTuoZoSCNzWZ70tHSalQzEiKzFkGUXLBHk9d43jvR25CGf", - "W/n8USQdKLbg2rBWnGKIP2jCKzYQ21dRY5iyw//vh/9x9vFp9t80+/1x9pf///TXP7799Oir3o9PPv3w", - "w/9t//TNpx8e/ce/TQaeZWbZbTlPr+mdlOHhg8YEGreWdudQX0rDMpD7sktapsx7L0EoTHJarYMkGEzL", - "B3TuMNEF22QFL+s0Lv4UqKCuZ0CpuSCMWkpITb4Ebro1o22zZTaQfwZW9ZoebFEj0FnZo28P/IXgdYee", - "brvECWRKHXv/cAb3cQtZA87oBSvReDmc9QIvWmEbnmwzHPQuRuHH3iYtRlAMvzw4UnItbX/Q4VWAJR34", - "Fm6iuFvdW9FYHdBVCJmNWdArGpRct67riVcX63vcKGkVi/t4g+X1hx+7vGR6onHeDnBg+6gskQHq4RTc", - "FTfYDnyK7CL9x9WKEdoJHHhBIuYS49FFl8ns4FkIKx53Fp5XcFHOsg4v4XZe9nA4xxLCFq49hX5kruQK", - "Lluf14wVkAN6iRbWNU9LZ1aXNqmPL5ZegoCy0w7MaPk3tvnFtoVTtb09hzn2ljRqGi/leYnjRkdzM5tX", - "CvPdiDsxH4MWhtAeEuygbaJlod7zBpRyoVMxfosmJDbGghmzQjFbs7w2jdqzo1wP+v+75QG7hoR0+GLk", - "c4BJnrZzCrA/bqwdJ/Y2kMfbPDBaVUpe0jJzttwkNYcW3tp7x7xW+kJ9+OvT128dxGBAZFRlQdZILwQa", - "NTLGvV2LZTXkDmMwKKK8AqD7pDtjLtctA/AVpJToiK6WeXJYhBvTGPGja+oMwnPPau9p3nVOBrjEbc4G", - "jcIHfQ3a/gX0kvLSq+w9jOmnApfUuHLs/VrEA9zYTyHyK8kOSv97lzd9E3YQmniGLRkjVpi3RBPpMkM0", - "h2WFUTAKAFqu6MZiC6pl+xRH1CvQ7GS65CmzWFtdSaDVgDxrh7JP67ZB7Hc9QifWASsaPLl93s9/aLdm", - "0jm71YL/VjPCCyaM/aTgznWuob11PoHWtaWXhAUbE23dofwCE+4jubi8PTdaXBjlOvKLlU8S1kQ8Nbee", - "cHY3kWMaFW6fjwMgtgsxsRNRD9wXQTXpsShYGKhomZH38C6MZ+yxDQOegdG9E9zZOa5xKrvTaXpByeV1", - "StOHveSgOE3UjaQfnc2V/D3lRXvVnzaaEHulBx0tvXTuyYAUwzvp7q5xRCHB1k1BClLvjYHqvo7BttHk", - "WG0OZ/CSDfHdsQ2m7ZI6QMjhvkEYCFXn57+iYOntvFTgBXsOuVpbIk/6msYOyqc4fnNNHcx9fQS9mtH8", - "IrGYxiuwZYk2kvhOIWVa+3ROSORgGNq67GMVUytu2uS+kaiuy9nitKN52oaFBWyKmVeXe7HUMjFMLa6o", - "MD6HnCNgrrdmaNKxva6k0gayWSZXWbCcr2g5YN5rCGTBFxyTvtWaRSnLXH9SSS4MIk3BdVXSDbpbNjvy", - "ak4eTyPi5Q6h4Jdc81nJoMXX2GJGNfAijYbJd7GrYsIsNTR/MqL5shaFYoVZumx6WpIgdICCJnh+zJi5", - "YkyQx9Du67+Qh+Dlovkle2Q3z/GUk7Ov/wIWRvzjcZqWQ97RQdrqSXoaa8GnB7vaR9ENlqa1mGd7rzuD", - "XcbcGGjpCP7uG7Oigi5S2b62wIJ9Grt+Zx9EgSkzgWUi3KTnZYZaqpMtqV6m0hPncrXiZuX8HbRcWWxp", - "EmLhXH4UtOkjuQ7g+I/ggVyRtHLtbjU+6VzMP9EVa2/ilFBNdG1BbZRWjridEJcKrsBcnI02EbYEUzqj", - "RxrqfOdRwuXazLN/J/mSKppbUnYyBGU2+/7bPqTPIF8egfzQrMC5xgN+59utmGbqctxF82yS60MeCimy", - "lSUPxSNHqdt3btCdKU2Wuw4n24ccyyPZUbLtWEUjKnsj/BJbBrwhxoVl7IV2e6/szhGwVgls+Pnda8cP", - "rKRibd3qzMcUtTgLxYzi7BJCL9JnY8e84RGoctTm3wT6z2tD98xhxED5G5ti1THQvL8dzn89LHtI6JXy", - "4oKxiovFKfpvAzONo3bZ6JkU9YDGspKWd+K0JNCIVHRjdzmwoFt8w+eM6SyXZcnypIzaib6yzUlFOV6b", - "OMOmd3zcMteCCaa5HnjOz88/LpZWQrGf7UscaVkwIAB97vTdX1EP+ECE/YIJC/erF7ug7g3cdqvAUKed", - "OpyWP9jPro8dzKXvzWDe4V227Sy8b326X4TTtr/7rXUxDGoAsd3XQL+72DVW+e8HyvBqDIWjmpqWPrYT", - "sHvOlCtg0gIHdDBQYoIxorm42OmbvzNdxTvXdtip/vz8oxKFPbnnLnwOfaTadmw8zCsKdgkmigb6fEn5", - "gE+qZiw9of1gZ3wvleHotMPYZ3bgM4rmF0kF5Af7RQcnPvS0j9z59OhALrBGvLV9PvjZUsZYvmLa0FWV", - "3Duj7c7hWwDvit2+0MUSTM1yKQptMShnhFVSL3dlFNDpqdYCJiu5Rl4npsy5VJh9FnhXIzvR3mO3ZGtc", - "exvGTElphgC1cLYSEkhpCK3N0j5hPo6AQa2A7kow+g3kVhEFPZE3lsvweXtpWW6mhJsHOI5ynp2UrJi6", - "KBkxijFytZSakZLRS9YUFYHRHmjyYc0LDSVDSrbmuVwoWi15TqQqmMJqM7Y5yNLYyc33+IS4qF4XB/Fh", - "LWB5obhBvE5cpo9eCRateMVTZOG6P0OtB83KS6ZPyIcriUDoJreBttxvq8esNhgzWPD5nAH1gOWAKA79", - "mg8RTFAeBUINwrBuTXdPA3oYluklffLd90OI9uS771O49v7Hp0+++95ywlQQWq95yanaxM1sqymZ1bw0", - "LtE2JZcsN1LFGgcutGG06OEWaqPcLMDLzGuROze00CUuYvP+x6ffff3k/zz57nunvopm8VHQLsCOiUuu", - "pLCfvMIwYIibMszG1lybz8AtmbXIQF5Over2aHI4lrV4jo2IC7xom3M7JGyF+il/8UtWLJiaNg+xpatN", - "zhEr3EkVccBzhiFi9l3kwihZ1DnDTBfvW3QjAov3QArlEyJ3G7jrvopQA6fXpAaehZBXIAE/RoFMyPYK", - "4Y6xS6YwpqcZ6CE+DhFc2lAFfkrgtuSWyopH6ae9rhaKFmycFwI8Vj9jj5C4wY9wKfcb4BfbvitgtWSA", - "FmedZmCjQA7Lo8RvburN2UIlBuW3d0MRlC+xMo9iJYa6QWUUaDvtSWdzxjLLCCYx3kpNkIArz1llMT2u", - "RMmYfWvwpsNdhgp5nmkLQdAYhJfWYAFMWU7LvC5RlNjCQl7ltARLUIPYJZsbaXEvrrTVmAK4nWsGHuJY", - "UgTnU/YNi3pA2qhLpjauBWpefAUPe29Ux3WnzypnJbtkZRJwRhXwDj/KK7KiYhPOwk7RgDGNIuMC5MgE", - "g4cInvbPTikUgY/3zCHkdiDtUQxsbhGfc8UUlwXPCRf/Yu6ix6IDYAyWApLCcFFD8SfFGrjxqScQotsN", - "w+1jgEq6FFu4qGEWsCaKQ7Cr1mkXkaDQDobQhl4wBNsHEzvuZuyZKqZ5UachmyuatyHbDxnd5X1HDTtV", - "4Wj1gfCyQ7zCJd926bq43EGbzmn1d2mQTrXo8hhiRUPEF3E0POEs7jJQ+ZYDGgNpJDzaUe6WMPYlU7rt", - "hhyZCdh6x9i2RWt8zMvlUxvsP0vm/dH04HwbJMcNznn+GQPvob9Lq5DawYGkZQEAfcVNvsxSgSMOAGxh", - "YXjXFeH7UyJ3AbeQzecsN2NggKgdrIg1CAV+tlC8YLSAiPEm6grjrbqgPPxJEju0jlgeoTkIEg3HA6M8", - "2iOhecCQXcj/ixyJ+y7gHjwhRlwDz+O4s09umWvjkOdViHqnZMM07ErwLo/uCGQmSZt4/aQFK+lm25TQ", - "oD1p4Hm9cRvfHEjgYR8U9GYfDEL2U7t7tm1y26S74HA9+7ciLrXTO0mZcHLzuTRDCJXLSpjw2UzasCwy", - "0xWgsS9XOyWzlkHi7o2Kh0mLkY5r9MEnvW2AL34f4I/uRnxm64ovs+veSVzJr2lEiZLKJlGmCN+jkGiM", - "M4D1++R71FWRHYlNHUuWx6h7sG+pffrrJS0HAi3fsUoxDXoCSj789elr5xQzFG6ZpyMdz88/UmNxCvqR", - "wWRTn6aTgcwQ5+cfZ0AxMe9DOI2+dTHpQ20JEbfd7ede7+u55A0lUY021Pvi9wH6mw8AIxXlztGriTXt", - "76wLOu5Hd48JImsOuLsIF9U7eIV+pHr5kuZGqk0/g6sVrQdS65yff7Tnvc8Wf/19mtxbENKTfIjy97RV", - "ZMH/D3zvPD8k5708PgQS+Syp05z5P62kHyXtCd8n00lPD9CcRZyHOOFntITPmNuQ+Epu/ZMeTNdczLIQ", - "NpKq6DiduHTLcY7ZnaFgXGcrvlDA8qRHHU4THT1RiRcGWe1EWWTH1gzz4h0kbS28A3EDXvQiuJlTCP1K", - "FGzNVGOZedOsrmMpR/URFAbWWaNMTdMmRPa75Q8wDt9OoQ0rtmhr5nteRfT4KS2bNmr88nrjiwzYZJFd", - "Mb5Ypjf27bWGtmz07kO7vPtDSxG4N6D1f2ovJGDkAKGdN2R4azL0iGKDb4AZsN+bJS7/voSkKmZlmGoA", - "XFPsiQj/PrDZ3cpCCUKt+aoq0fnTkZJe7qu9Ek00ASa3H6906KCPWw/fYNf2SDx81MZ1Ydmdkmp7rMbf", - "xXO5qko2zDxXVCD7POfCye1XS2riYureBiTzvFaNEbcbjfELLTlW+dWQxVBIWUHawspwYf8DCRxkbfD/", - "jCr7H3Qqav8PsSrik+xQEzgXSH7lB/KRnJPpBDtPPGYnuaikY1JvU9rprPx5ghM22NIEYwUEJDTZpE9p", - "btD+6Zw1BTNXUl0kxJiZBn1Sy68qLvvap6ZUmbqiKKLQ4EHhUriGrHABNAeZrjV617T8J3bSSrauLK7t", - "D2ChVpcjIQybJ8UlU872IV1OSbRyYJraXsIm4sDbZ00pUn3NBECj3FD6ElpimxsmEVWDad8mUGupWE6O", - "fIX6Lpu52lRGnkIbaHKqjapzo9Frs5mzh5V2o9F5aXf9vC5LYTkBqTnaM43MFLtkdEhND65a7Lea2UMG", - "U51tTMIAqYMdS7S7e4xjp7cWAIldYTBoCh3syo1Plkntnq9o9RFn+ZVk5B1CHEopgEfeSi+q/T23cKgU", - "6JqWJhuUchx/Sd7T0sRshAXI+XkED5nhxLXIwSZHzz+HyGFhuj4K2gWzYhu7f3UNdn+QdsC84aFADqx9", - "pS6Zwljo0ejwi+/xaTq503W8Cze2TxWi9Y1bRbwpEWlIq1j8V3+dmlTJVBQkml8TuBsJX0G4ukwYtblO", - "miG+yHQp91jee754bzvs2FLfrLenpbxiKrPzbjni0psaMd4GW7ZSSYdaLjgeekqwgtjF6OttBA681064", - "Lrv3ohm745RCy1yKrDX73VIdpJcZYFcWshzs2D26au9e5WXrfakWEIkNF4t05kdL6C/Y5n7oEhIex73z", - "BBPvsDIHBI2fgkNDZGS6ckZkNBK2GZ0dVSSsuAacpiuXs+Vemfa9avyLVjxXkoIzRpNymvU4WCfsgS9j", - "2I1tDiZp5TIm5sbOHzYVC065/VI7K1p5eQvkcMsEn9ym0oq8C+7IfY/SXApDORTUSTL36IzLygoIVaMb", - "P7lX6PtL9DJ3fE2270++AgSKDFex/7b9f3/LjGLs7j1cL9gmK/mcGT5gkC7ndiV/Yxvim50cjKcYypHU", - "MviB5qHEmIAm7xORCr8s4EucXoogHYUgae3/0qRghqmVRcWlvCKrOl8C704XzCdYAoMNeJZ3JmqN7jNS", - "tNODufhAXdEcB8Kw/5KqBVPEReKHuiTeALSiHO5J4w3cjc8FRzGaMsbtSvv0BlMBRLQLTKdRDqhEdikP", - "xgXbnKJlEH6/BiEZTiU1ABjklbpFkG6UnirOabYDXy9aRlUs9tVK/hbAP6Bx1cLnVAh7Glf72drGLg/W", - "Adeh1qy/zvHROPHeJkTcZm1jPQP6mztg0N9lxx8o2eLMvUDHoS8B+Mg/v/4nUWzOFOitvvoKhv/qq6nz", - "V/jnk/Zni21ffZV2akrenMP5DYRKAHYMN10SO9oFYDs2VHzkNYbTouOafdCkAJfNsuyEPImCQLIBYE8o", - "RICwUlYs2RqKlcUvKCSAU2xRlxRDfbgQTLU6jcn0g+K/WQun6oI/P6xFqm3MTkLraDtSBUKjKszXq5zb", - "KSeHeZZyyGh03RGbnEjNiJhd5SYjvsSULmFEH2F6kzE/uDF2lHA8P/+oFwLUcl4Zx32WAGCA8YTb2BQy", - "B/gyjz5TUQhnY7/VtHThegKC4z5A2p78ggms4GipnKu+S5jQtXIqQQsrjGdBccPI+DHXTZPr1nIcLgh2", - "fv5R5aj9dR7tLhkEZJ7CrpbNKOzhyO1FVWx7K2IOJaOznC21c7mGPr4YfEV3iV6Axmo1bMPvZIuOI0sg", - "46LvPzB8U7+kKYWezkXYJJXsvMyY//7hqxePCO8WQ4+zPkaC1u5lxyVUxkGEGUZ6sHRzT+4DxZyxoXCe", - "TmAhmbMBVfDW8h12LJAKsY4HtOq6YO+EcmRWhR+phiodrnkTSX8fUym0gCSvXiT5jFZ23L1LQkwnCyXr", - "dOT2QoFpqOsLaoUAYLBQgEfnstMn331PCr5g2pyQf0ByPXx8+3XR2qdJeFNvrVXKkwBgIUErskEuGDGa", - "c+kOtBcczF1QIgxz9yd8nfzk0wnwJZlZpwLcX/V4FlK5CE7ILRrRm5bb+yHC2rkwiiLxzeR8nsy3+3f4", - "vXGLUJ4mK9Y/9RFU+YJtFLsu7/I36BxKjA5TnhIoD9TauR7hKRkdiBwo14nr882TrLlBJ+S17U2YmEtl", - "pepVDZY+tobEfM7gFnOpkL7ONOWhIXOd+J0pCUoDQaQzbHfvWNhsiLKkOfDz2kURWxhCYt2gmHz4HriZ", - "KQL5CGXS/lUjtTAc2R+7jb9Eu1jZh8cC/Y8lLxNYUEn7XcdwTImQRIJzUNwS0xo0WRcRZhcW3kKku73m", - "cTrxIm3qt5gA8ZCvo9oajUYiX1LRVGzfXZKhj5PjajL3ihIlrnm6YoRdwAIXsDgInJ/XUU/IgfBQ+wHY", - "EMUwQ2LQnt1xMiC6WTFhrkn53mJv9E2AerZquwSgBiQA33tXHeALtsmMTI/N0LCEnHkQtUBPitQ2WuN0", - "QO4JMXa+Bn7Du+INsizCvAaDbmS69HpSJ9IFf7ILtmm8XeJagSg2XUPKwmcxrQX/wFeskUuQkUuxQHzU", - "k4jiZVquxZxISLIfbFlOGGY7VugBrMC+23FitJ03QtvI0NvLc3SNWxC5IUEuji1hHpuKtQP7wDExKOpa", - "SS5AZ3BCXoQkMeCHiLH2TeYY1Gd1vRUxI0rIksyV13tR5fXV4NAIzm5waxKEwDVA3si26XNJrgnN59Bg", - "SBHkm63nTDXtUsoY33Kufm8a9vVAvllVgWfBgEbLtdKmAuPQ0Ek3TpkV3Uw8MziZTuyy7D8WbPvvXP1u", - "/6mqEqqcVvO+T2b6AjucyGCeRIj7pC21thjJcBMb1NqhAd1aR88F7s6xBm94VfdVT8YKdExH3vzwnJbl", - "h7VwfoD9sLctnpe0wtC3187jMlBoS8ad+67XWjnqEFtiaJ5bFq9oUj5EcD7QpFs3BRNB9CunbPHG3Emh", - "uyxAjJtULQbXDQqrPhvKc0LVosb0Q3ewvh0rGJBsaMULl5CxX8jOsWxIFmrFCiKVS+XF5y5P21Alh91l", - "qnD3Kscz8rxhDZssFAOYPrXCD6tcsnUpsjx4ltt30kqYRpJz9Mg+n5yQV5gzRjFaIIFV3LBUHaXW+iH5", - "7RWDss4eo7NwulEVvBN7i1o1tzRgtmLgP5EokfZF1uOCE9P1wIkNUSXkqtqH9BlO6Hm/mBgUCxDSfEHn", - "NKoy1/n5R1bBxWqXvYjjKKoqFOsqmd3332oIgLMEG4Yd0NFKxfhCDNRiBwSZU/8Q6O5xJZ+DNpVy6Qbj", - "g9e9VyKw49cjomB5wcEwhQAtMihlv8XlO0Few14MFIdHAheSTeom9ka7VUY1MMYt0ZOZt9EKAbE9K3vI", - "9V2jpNqN66h1BmhRjV19WwFGicpr8VvYHXoXZxZZObdyZliyobQLR/qkWObfT0+xRIHVHOomXulcPCW/", - "MyWdsBqGshei0Y27NOAuP+pJolMorKJ73bpT7lmwBhe/hTscLAB1fv5xTXtcBsB0A/7iejW8dp7xy4FS", - "IvEZe1OZqyFyw0pAOOOWjW1iLvsWMVrAvkb1F2IfLyQyoaAA7rarqQLIQq8GyphsPc351tPcMn4rA9OV", - "lw4x/XCafDppEnNdXfkdxx6puM7hGMWmolR/6jGXPzgPjEINLyHfFDn8rFvQY9iUTil6iT5FI7qVyrRj", - "vDx8J8SRkHQib83Kuadm3jbnrccxptmXCd+1Fa0OWj1uJ/GIIB72OWCDHgdNXjP3MCdSmeMIjW+D5TW9", - "NTLBMu65dj96+gjhazedFY2rQuilrMsCC0OsIBdbI2MmTscVgAp8YVOQC904wOsiDrLW0QzxZhPyyo5M", - "yyu60V5R22DW8HB+V7F8REJJGCdrRO1yem9Ujm7iLOcVZ8IEn5v4XCySD6s30wM7NamlOphFjl8GrYVz", - "vKdNJbW26c1b3ly1KBq90FO3zbRsqwtwYK+Ktm2e+7H9isKRRg/a7pQiqXp6YUt3ED1nG91K7ZxecV8i", - "h72QyuE0w+RNSNEOAB4wygjbyB7aG6ouWo+gu6xuALHAdAKtUVs8RpQEQLMSU5F2YpCHImQ0K50p4209", - "K3kOZgRw+g6GBefxX5B3VBRyRV76ZD4Pf3n38hFRTNel8UjmMxtb5HOQfN5yAoMLr9Tcrfx9FC0Tls+F", - "s6gsuDYqobi881VBzsddDke20VybxusIDdaY7rEXEM4dFUw/QzDhBdtkBS/rQUS2rS6KdsJNXc+gLBwX", - "mJV3Rk0O3iw9EPSWqXd4ONg2JS4V3BxuutJxFwaW625Ma5aqc3/uGwLtECW8eXU79XSWm33Jp+uG9NPN", - "dD3+ENnDJkwiSgRsz9MXROk8/DfisqIpME7Lch/aVSVsmK22S2lT9FMEz9DIkLDT5bQ9Xtrt1PNZMAkU", - "PuN9jstOCK+/e1sazgj6F65YaRkxP/NaFLqzhU05/C321628j2N9fJutptwhpmAsJ9AKmm1DAoZLF3TS", - "xEtrLXPeGOGh1iRWlfy7KDcuKV23okezlZWSl7xIFaIv5YLnGlUw+1qMX/u+n6aTVV0afs1x3vi+aMJO", - "P4d84Z5CUVBVEFY8+e67r//SToVwj8hVf5OS7j1uWU7LSA3P23xsWN0IIuaP8mQh+yRr0NimFo3tIRjX", - "Uolbx9vIAJDh0HevaHUOIrMNoRGqS8u2l4Y3P03tb0uqlw3pjMoWQxlpShy96nr9QXxRZOi74/Bzh9jZ", - "jRwzOtdjiHA0l+Q+3I2YPCI+jCWJbyJK0lvhyi0R9a4WX3zQJex1VTLL2zU0cDCNjj8afPL9nO95v8p/", - "PF5616EBlA6UlhPBvKyWmWw4LlAQNFBdwzu4tz/vY7hSefGWimkLUdr7ZqmSmUa25d9sMh8m8qrvdbbv", - "O3vayUwC+zbI4VYXnymBzTYcuB9ZHNKOWNtZ5qFcDGRMYF5IRtVNQjXMPUdZYbeh/mC+1bb8PD6jiQOn", - "6+U25J6mK++g9iEKHY0zdJFXiP6NVyPwsQLz1biUe2j8dQUA2vt185D8TxAhMJeY3UAYmpsmtfjkqRtp", - "4or8TpbGVPrs9PTq6urET3OSy9XpAqKcMiPrfHnqB4I0kq3Uaa6Lq35ln91yY3iuydO3r4BJ5qZkEDAB", - "Rxcl1D2bPDl5jKkXmaAVn5xNvjl5fPI1XpEl4MUppjmenP3xaTo5vXxyGjtHLVKBD+8ZVfkS0di1PYE0", - "ggzF2VdFaPRSqqd+OGfoAhvx5OxjL0McqFYhTITbv3+rmdpMfGH0WO/XmF/79HB3AD3qpTR6/JpaYUoC", - "xUjuufbItwDcBwi7ZIJwxMSSr7jxKlHFaL50bFoCZmi7J8BNLRS6YBG8J+RnzaJaZPICYo5QvvARDL6U", - "Vug0AJgdIgVXQ+P60eO4a062AQdQKrytZQFRdmAmE5Gn8kmrmI/Tzfvyd5jtNN+QWpSWofQGJ7AT67A0", - "qPOE6Wxy6nbAhfd5N2k9fAJ+ksxBmFkI9zwRV1cbhGHgHpxjN6g1nazscHwaMrfGniJTNFjLDeS+08y2", - "C7lQOyaFqfP0sMPi58gVCXwQ0I9kaMHO5zyjZZlaZmRd7C7zr2u3zAb7cbW6zpfgk9QFtAsZZvN0mShC", - "QJHbm6nrH/mJ+NjM4B8SWorWBo7oY7eDratSFmxyNqelZuntYbjI1tYEjtB74OLeOVeYTlSqRudbnUX+", - "IJNWRK1tIaRI50rtpSQ0GyDd9tGZ7Hvr4Nrc3ytnp7jRffN+t5FThZFNaDlkYrWX0GVvSr4aITZ+mNrt", - "9Kbd/nkIfP/OeF8Wb6d0sWJYULZiCoYUOVjTNFALr6pGnPfuVAXXdFZiPlzQQ7V8ceB9AD6o7YIWe9/M", - "eQl3CE4R3z7MFBHsl6KwhCnjonnYyUvoZYeebUhEXlrDbBkBNiCQRTTewgUPM/wkReY6raigCwujRV37", - "wsYxNGhyxF0F3WaMvNtQMtSS3AML44S1w0xJ1xNrywy/WuEca0gAtXny+LHnH51+PRrt9F8aJcFmwGEP", - "9n3i4VJEyJfj2pprIBRZbZ0C8k2rqjbD3jFrkwG30h/5Z+0eioouuHA+ZXCyK3qBTD1GRjqXTk+hfGoJ", - "ywIFc6RjmtytGaE8bvjS9gb8muT325A/BNeuR3aB397oHAeLhwwX8eiswzccA/Y7h4Dolo7FRz5NJ999", - "6UuwSE0XGmq/gNwx+fVTR5o5/cP7VPPi06Bo81rKi7oKRpGoQFdfwsG27l492wCR2CrhBFOLf3eApEDB", - "h4aiBCAn8R4ZVbO9+PWxr9ABKeaRTz7yyXfDJ9/KU7rHA3qLD2b6kTq+UZNvH397fGbvzzNbwuO345k9", - "7VGAXe+uiBw9u3RUVkhuy43XoPvgKMwUtOV1flpVkIwCtNL6Pr3TBxcz/qzP8lHRey1F74Gf0s5930M8", - "bWZpbupRWI1Cvjobe+QIjhzBl8gRhADTz8IHeNHk/rz/t2L1PL75xzf/zt78cKPHPfRxLc/j++7f96BE", - "OT7qx0f9S3vUE/mk93vivbYyrcy80ZP/HId+GoN2lP+PvMCRF7gd+b9FAPYV/Y8MQSLHy5EtOLIFXzZb", - "sL/MHxiCji30IKzAUQlwfPiPD/9nVwIcH/uj9H985r/8Zz6OTBvrWNdONPShVfpOMUe2WUEEu7KXzUgi", - "S/sY7Xjh44F2PfDHd+MwkUFRPS47y5yvHXX2WaBcfePGh1tIwzAX/CAUkHcFBtvbcR8j6If89sPXP5IT", - "++zm8aSHS8ye2j2+gDhH75v/L7tpHhHrJj1IcNv0efpDXCzk0Nd8QbKQpcH+ssKfIPL3PV/Yn0r8CXIO", - "YMR1ags0XwzvgYZuK/zHjjdqke7yRwtpp1uYbRzznj6SNOd7L31f/ZTUQOTFHIPi4qlXXGRbpw8NDgLC", - "jM2liwKKYKDrHTD4BvsGTdyqIONXFq1pwS0Bhkrb5I2jN1SQdy+fk2+++eYvBO+9FWwQXYYWjENiTZMY", - "uEA3CmrC5zFU6N3L5wDA++DSOqrVzkMNGHWolcOI92/hf+J40z9l0N/njI3AVTsNhBMqscjTdi4llILa", - "qrA4rKD9JxGQp5OuVHHzqo4dQam9k50JjzFg/6Pk1jF26TirRdv4MpTYYg+T8u2beTFMF+WHVpmKcOmQ", - "YwiRuk2SvSRBx2bXY7yPGuej5uBoav4zmpr/R0cSR/t0+kebWO+OKI5q1Q3pMJsm6WjiFEvcfTJ2ssV/", - "OoPhrZGdPYnN3QWN3tCKdDTBfCGsbI8Inc7kepAQ/S9g/6z03+JF4RrO5JrYezV17Ivu5KENDaC10zk8", - "c781pYedfn8hXVW23FISqhZYXPoBDMbF4gwGeIAZcDhQk9rxIdiQC3P29ZNvvnVNFL0is41heurgAejI", - "998CNLbrg9n33z7w1gcK+eXtT2dPf/jBjVEpLgydlcxpGHpzaqPOlqwspevg+GPWa2g/nP3nf/33ycnJ", - "gzGkXK4tNX8qip/oit09UX/anB0XcDTZQU+k3e6uNj3JgOL+jlcM3fRl2Eb8n8l16rrbOxMlFTma7Y9v", - "xuHeDF2vVlRtLK1nBq59hGrOWw6VAB1u9NqPDdP7PjfNCwP14cMTAnleaZsL1FJZDrNka57LhaLVktsX", - "ZXMySifzDMC7c3p7VA7cL+XAcLXoihfrTuF2wkXB1mn5PaD7KE3DM7l+4aaUyYqkX4I6AG8DLnwMYXoW", - "X+f21T++dMeX7jZfOkS7EW/cXlqd01Iu9B6qHWLbjxAKXsuF/jw6nuPzdBivt8/s0vQn9S+CokvBUN8r", - "zI9pgV0lre32LWyVNVV1byc78P1na27V5lHKReZfjP3TAC1e2K5fNO90A1XsNiXg9oCq2JINLbcJTKOC", - "oY6G3ePjuMdr1fJFwIzfd+iFsHt2O/oOLeJB56sFN0Pz2W+Tu48WPIZ/HcO/jqLpXXoPwCGf/uGv526P", - "AbjmYzKQ24bjpcm4fvrRV+BWfQWAzI2lhXeYVBqmPJKbozLvfrs6dCnm6YyWVORsp0YOWW9tQA3ty9Bc", - "LSUQFJcPHwjMVorqJzvKRkfZ6FhI7xjYNDaw6WBM12G5kZh4jpLS3nDBj9k6U6/erHkajiLbn4kB2SfV", - "Rcs8AbpYR5+25bvALBf2ScXMF1tlvmO2i2O2i2O2i2O2i2O2i89jjT7mpTjmpTiKb/+z81KM8ThxRkwL", - "qBQMXZlbjfH5H+RCbtsJpbeo53I144I1ApBfQVN02kh7UNBoSU14h31DI4kOXgY71pUpWQ68r+CEA0Jx", - "zvgl/HeuGPudZYYqy1yPeW9bq/EAQmnMaP64NuZea7NMMSrciM8H4qtTqxWkoTUhVy2hxK9kavnkjazJ", - "FVyWkl9Af1dX0276ilgk7tT6NpIYVQ8ap133DODZmXlkehcGoGMSlWMSlWMSlT+BNmRWyvxCn/4BR52h", - "HmGnERs6DSkxntmPuxQXeBlxunRaqBigGxK1HxktmCLSPvrzki5OyD/s5YTbB66lxlPoaaOzgTWSQjLU", - "hTgFQJcH0AP0bwlTZnbK2yWBW6NV4CSOgeFf8PUcpZqMPEPHZuDtaiQ9u55mG7kGdrzLtAcxcb/cvsFL", - "9ajpPGo6j5rOo6bzqOk85vU96k+P+tOj/vSoPz3qT4/601vXn35Oneft1wo9alWPWtWj2uazhgXFR3v6", - "h5WJdgcGESs+lq0XckjFGmPdmOggJ5TdXQ61OyQh0XbtdVnHX85jDM2RvNwXrfCn6UQzdenveq3Kydlk", - "aUylz05P2ZquqpKd5HJ1CkkqXP8/At8vVyt4qMIvbuToF0fKbPd1JhW3b2+Z6Su6WDCV2ZkR5icnjyef", - "/l8AAAD//84PGZ5wfgEA", + "H4sIAAAAAAAC/+y9e5PbNrI4+lVQuqcqdq444ziPOjtVqVN+rG9ca2dTtpM953hy70IkJGGHAhgAHEnJ", + "9Xf/FboBECRBiZrRjO2N/rJHxKMBNBr97j8muVxVUjBh9OTij0lFFV0xwxT8RfNc1sJkvLB/FUznileG", + "SzG58N+INoqLxWQ64fbXiprlZDoRdMWaNrb/dKLYbzVXrJhcGFWz6UTnS7aidmCzrWxrN9KHD9MJLQrF", + "tO7P+ndRbgkXeVkXjBhFhaa5/aTJmpslMUuuietMuCBSMCLnxCxbjcmcs7LQZx7o32qmthHUbvJhEKeT", + "TUbLhVRUFNlcqhU1k4vJE9fvw97PboZMyZL11/hMrmZcML8iFhYUDocYSQo2h0ZLaoiFzq7TNzSSaEZV", + "viRzqfYsE4GI18pEvZpcvJ9oJgqm4ORyxq/hv3PF2O8sM1QtmJn8Ok2d3dwwlRm+SiztpTs5xXRdGk2g", + "Laxxwa+ZILbXGXlda0NmjFBB3rx4Rr7++uu/ENxGwwqHcIOramaP1xROoaCG+c9jDvXNi2cw/1u3wLGt", + "aFWVPKd23cnr86T5Tl4+H1pMe5AEQnJh2IIp3HitWfquPrFfdkzjO+6boDbLzKLN8MG6G69JLsWcL2rF", + "CouNtWZ4N3XFRMHFglyx7eARhmnu7gbO2FwqNhJLsfFR0TSe/6Pi6UxuMoSphzRkJjfEfrOUdCFpmVG1", + "gBWSL5jIpT3Hi2ta1uyLM/JCKsKF0VN31sw15MJcfPX4629cE0XXZLY1rNdu9t03F0++/941qxQXhs5K", + "5rax11wbdbFkZSldB0fM+uPaDxf//T//e3Z29sXQYcA/hz1Qea0UE/k2WyhGgeIsqejv4RuHQXop67Ig", + "S3oN6EJX8HS6vsT2xesBu3lGXvNcySflQmpCHeIVbE7r0hA/MalFaUm9Hc1dX8I1qZS85gUrpvbM1kue", + "L0lO3YZAO7LmZWmxttasGNqQ9Or2UIfQycJ1o/2ABX26m9Gsa89OsA3Qj/7y/7pxVLIouP2JloQbttJE", + "1/mSUO2gWsqyQKSPHgBSypyWpKCGEm2kJaxzqRzHg1R36vo3TBzJ4QALMtt2W4qiNfr+PnZ/2KYqpV3Z", + "nJaapffLrz7eJFhlzFvQspy4F8syWm7KLPxAq0pnsOJMG2pY3KaqbAshBUswIOEHqhTd2r+12VouC0jr", + "pDmdLC+lZpmRexgwz1PBhkUsU7xjB7Fj5N2SEZjcfkBWFDBbWCpdllti3AFYhCCe+ZoSPidbWZM1XJ2S", + "X0F/txqL0ytiDx+OrMUpWmo2hNy9zUig9kzKklEBqL1ktGAqk6Lc9vftB/hI7EcyL+nijPxjydxltm+/", + "hQ7BmRLFTK2ExbJS5lekkEwTIY3lGwzlosuy6wH4Y3j2gO6khsyi3jD/Uvoric0tqwJ7UwTWZkoKVjI4", + "n+b+wK/aKLmFc7NYPCWysvgqa9O/16Jww+Ln7jUHnB8UUOKV7Fl0yVfc9Jf7mm74ql4RUa9m9sTmgdcx", + "0h0N4KliJAd0m7WIVkUXTBNmWSGO0hXMYw/ZnqFiNF8OE1SEaQ8NXdFNpmQtihFChCFSxUyarljO55wV", + "JIwyBEszzT54uDgMnka0icDxgwyCE2bZA45gm8SxWspiv8ABRad6Rn52zx58NfKKifA6Ip1npFLsmsta", + "h05D3JKdejd3JKRhWaXYnG/6QL5122GJG7Zxb/PK8dOOBLCCODpgh0NCOQhTNOGhQsOMavbdN0Mcc/NV", + "sSu2Tb4XXQTA5QQtxdJ+wb67VxFm2HOpR+Ihsgcx/u3EvVF4B40yJBsJ9s5+dUQlrRFq9R/Bcsdzoz4i", + "u5VuCMfwL/PQVnRmujsxVPNFhiP2bglfvLNsxJyXwGL8y14Of7K1tu9S+2w906H5QlBTK3ZxKb60f5GM", + "vDVUFFQV9pcV/vS6Lg1/yxf2pxJ/eiUXPH/LF0Ob4mFN6oqg2wr/seOldUNmE5abmsJ/Ts1QUdvwim0V", + "s3PQfA7/bOaASHSufke2EZ5EU82HAEjpR15JeVVX8YbmLX3hbEtePh9CFhhyFz0E2qErKTQDrH2CjMQb", + "95v9yZI8JoCiR7zA+b+0BCGqGbtSsmLKcBbrZ+1//0Ox+eRi8n+dN/rcc+ymz92EkyCkmaGnDC8wNY6E", + "IelyRA2ZgVVVG3zaU9QhXOf3AbbunM2xyNm/WG5wg9pgPGCrymwfWoAd7Pp4u6VbAsnIfesKFXe4j/i4", + "Z/BI90f+WTvBr6ILLmDhU7K2bPaKXlmqQIU0S6aIPQumjX/mkfzhyx8Uy45XcLLC2SR1YxJnqm99qM2p", + "vbLs7ltgd49xxB2x8YCzToF0Ovlw8r2NPSYKLI509js17peX72lV8WJzeflrS+LiomCb9Hnc6WGXcpEV", + "1NCb4ejiue2aQNBPGYfa1oxjIdBxkeeAU7jfF/VY23Xky3YjGnuirIlbcXuiqjUzT2lJRX6U53Tmhhp9", + "wq+54ADED6jqOh2zP+awlcc4Yre7R7nIqHEffYVPh5u6w8GOceujPdaRjjrIe5YIYcpjbNLHQvwTxh8X", + "45+WMr+60VnuOioYdd/McnP8eeUmNetTuSFcoPbPcT5P5YZ9qiLPzMI2+lo8lZvnbkqpPm9pBBc+BoOf", + "Or8YDUZeEe+sXfJflZLqCKfrZcMOPNPJimlNFyxte4nX6BuOWZQHGA6E2SWAhvoHRkuzfLZkd3BRo7H3", + "XNd3jTL2CBt7pyQ70hvvW3+0qj3CXnvYA6lsNI3+1Hfv0yEXrS0fTxBbZ9olh+PPWB92yB+8/SE2MCRc", + "+pzPdvQc2ZOizq0RzYOX4lI8Z3MuwNp/cSksHTqfUc1zfV5rppyAebaQ5IK4IZ9TQy/FZNp9oIZsdeCC", + "5aCp6lnJc3LFtqlTQN+wxAjS0DJyYIjcxJzZuLFA9PEMR80sOsjaZM4rNVNsTVWRgFcHozWMjP5qu2ad", + "Ejc22tad16sbP437PZ+nvs/9TncwLtr+WvYgf5TGWaDpmiAikVozTf65otV7LsyvJLusHz36mpEnVdVo", + "vv/ZOJdZQMH2dVQ1OiwWzjBjG6NoBj4laUTR9Qpe2rIk0LbtuKbkQtGV80npusTt2GmcfNxLFS0LVvQW", + "e32YRmJE56jgd7JkZd+R7tCDiWTuG5/LHrl9h2v3uygCgS4oF9rTds0XwmK18+acMZLbt5wVZ+TlnABt", + "mrYCGFwohqN7gQBwjQ6Y5J1dF7hIkJwKcMysCnCF44JQse0aZTUzxlvC37Artn0XeVgcaKl37lh0z8NW", + "1Ha48Lg1p0rWVJOVBCt9zoQpt87DK4GCaWBqLgy6mrRcHXuARI6H9lZE+sMh183ImY1WFVmUcuZoR8DF", + "i4CMvs8wmfjJAqCPQCKS8nTbFXTf6vGaDbmsHr46O96tLtnONd0YueZcafATZNSRehpfhhvgmHNi7IPy", + "jyUDLkoqcOZr45H2lzeF3sFHCZwtmTD8mmWs5As+S8U55bT1YnpPV+cRGkbQhM8JN5o4FaoFgguiqFgw", + "y71YjkNqWmJURhKakmqTLRlVZsbogN8cHEzjKN5atu1P1pZkSVFywaZ2c9jG4jG3O6GYYGtW2NVw5doQ", + "+4bXA089AISAp45gFDy+O+wh7Fl6rhUXmdu6hCOo51/C7noG1bsFxlcJ4MLvKwYBDHJtz8VCIZ3vfc+z", + "vLYiaBq0iirDc16Ns7shID+1+thB9vFuSW5NzrtMWY9/SoKMjTO75v5MtUavbbsu/9j50VHuAajPCLiq", + "uU2aleDIHSKn8LypAg9zv1SMJBoCRw+xx37y9trjS7ek2l88iJPw78QojnWAmDXoa+lohL+x3MHtvCW7", + "pkM7PewbB77hXXc3YCH6cQ7eqRQjQb1PnHeE895v9l9L7+qytNSmFldCrq04c4h/23SCV74P8LUENgU/", + "e8RwIH6ho6OxcPx9Pgf6kREuCnuJQOigxoetyJxjdEBDky0tX9gfz+wAFrvsAKNHSKGtGxI4bClLHJj8", + "KOP7JxaHACkYh3eF+rHhgYn+ZmkpHNh04NjRn56LNMbl/pZbOaHFFQFgEGs0Y0ygWz7hYkosKbumpSVl", + "RiJrGgZJi1oPWlKSY9z1wyERLK0hwhUB53LQmpDXuclqYvbfA52WTXZAPJObDGL3+rBCCF5VZYGISVFu", + "MdKlK6fDCHY9MgcM8V7KV2yLQTYQ9gW3BDSyjn7MWCktpy97GNYc1B7gbwv4EaHZzeCnsFkD6iHn3aDd", + "jlCtvVMP8NdDaPcAcOgWAHT178G52ml49ipl2qxM/+FvXsNp48yOFDlNRoauYh/h21iUPMWB/e2r8YJP", + "609d7ieprGu1Ithk5vRQkSyUev0sOcql0EzoGqIhjcxledbT0mlWMhAjshZDll2xRJDXW9840tuRB3xu", + "5fOHkXSg2IJrw1pxiiH+oAmv2EJsX0WNYcoO//8++K+L90+y/6XZ74+yv/zf57/+8c2Hh1/2fnz84fvv", + "///2T19/+P7hf/3HZOBZZpbdlvP0mt5IGR4+aEygcWtp9w71tTQsA7kvu6Zlyrz3AoTCJKfVOkiCwbR8", + "QOcOE12xbVbwsk7j4o+BCup6BpSaC8KopYTU5Evgplsz2jY7ZgP5Z2BVr+jRFjUCnZU9+vbAnwled+jp", + "rkucQKbUsfcPZ3Afd5A14IyesxKNl8NZL/CiFbbh2S7DQe9iFH7sXdJiBMXwy4MjJdfS9gcdXgVY0oFv", + "4SaKu9W9FY3VAa1DyGzMgq5pUHLdua4nXl2s73GjpFUs7uMtltcffuzykumJxnk7wIEdorJEBqiHU3BX", + "3GB78Cmyi/QfVytGaCdw4AWJmEuMRxddJrODZyGseNxZeF7BRTnLOryEu3nZ4+EcSwhbuPYU+pG5kiu4", + "bH1eM1ZADuglWljXPC2dWV3apD6+WHoJAspeOzCj5d/Y9hfbFk7V9vYc5thb0qhpvJTnJY5bHc3tbF4p", + "zHcj7sV8DFoYQntIsIO2iZaF+sAbUMqFTsX4LZqQ2BgLZswKxWzD8to0as+Ocj3o/++XB+waEtLhi5HP", + "ASZ52s0pwP64sfac2E+BPN7lgdGqUvKalpmz5SapObTw1t575rXSF+rdX5+8+slBDAZERlUWZI30QqBR", + "I2N8smuxrIbcYwwGRZRXAHSfdGfM5bplAF5DSomO6GqZJ4dFuDGNET+6ps4gPPes9oHmXedkgEvc5WzQ", + "KHzQ16DtX0CvKS+9yt7DmH4qcEmNK8fBr0U8wK39FCK/kuyo9L93edM3YQ+hiWfYkTFihXlLNJEuM0Rz", + "WFYYBaMAoOWKbi22oFq2T3FEvQLNTqZLnjKLtdWVBFoNyLN2KPu07hrEftcjdGIdsKLBk9vn/fyHdmsm", + "nbNbLfhvNSO8YMLYTwruXOca2lvnE2jdWHpJWLAx0dY9yi8w4SGSi8vbc6vFhVFuIr9Y+SRhTcRTc+sJ", + "Z3cbOaZR4fb5OABitxATOxH1wH0eVJMei4KFgYqWGfkA78J4xh7bMOAZGN07wZ2d4wansj+dpheUXF6n", + "NH04SA6K00TdSvrR2VzJ31NetOv+tNGE2Cs96GjppXNPBqQY3kl3d4MjCgm2bgtSkHpvDVT3dQy2jSbH", + "anM4g5dsiO+ObTBtl9QBQg73DcJAqLq8/BUFS2/npQIv2DPI1doSedLXNHZQPsfxm2vqYO7rI+h6RvOr", + "xGIar8CWJdpI4juFlGnt0zkjkYNhaOuyj1VMrbhpk/tGoropZ4vTjuZpGxYWsClmXl3uxVLLxDC1WFNh", + "fA45R8Bcb83QpGN7raXSBrJZJldZsJyvaDlg3msIZMEXHJO+1ZpFKctcf1JJLgwiTcF1VdItuls2O/Jy", + "Th5NI+LlDqHg11zzWcmgxVfYYkY18CKNhsl3satiwiw1NH88ovmyFoVihVm6bHpakiB0gIImeH7MmFkz", + "JsgjaPfVX8gD8HLR/Jo9tJvneMrJxVd/AQsj/vEoTcsh7+ggbfUkPY214NODXe2j6AZL01rMs33QncEu", + "Y24MtHQEf/+NWVFBF6lsXztgwT6NXb+zD6LAlJnAMhFu0vMyQy3VyZZUL1PpiXO5WnGzcv4OWq4stjQJ", + "sXAuPwra9JFcB3D8R/BArkhauXa/Gp90LuYf6Yq1N3FKqCa6tqA2SitH3M6ISwVXYC7ORpsIW4IpndEj", + "DXW+8yjhcm3m2X+SfEkVzS0pOxuCMpt9900f0qeQL49AfmhW4FzjAb/37VZMM3U97qJ5Nsn1IQ+EFNnK", + "kofioaPU7Ts36M6UJstdh5PdQ47lkewo2W6sohGVvRV+iR0D3hLjwjIOQruDV3bvCFirBDb8/OaV4wdW", + "UrG2bnXmY4panIViRnF2DaEX6bOxY97yCFQ5avNvA/3HtaF75jBioPyNTbHqGGje3w7nvx6WPST0Snl1", + "xVjFxeIc/beBmcZRu2z0TIp6QGNZScs7cVoSaEQqurW7HFjQHb7hc8Z0lsuyZHlSRu1EX9nmpKIcr02c", + "YdM7Pu6Ya8EE01wPPOeXl+8XSyuh2M/2JY60LBgQgD53+v6vqAd8IMJ+wYSF++XzfVD3Bm67VWCo014d", + "Tssf7GfXxw7m0vdmMO/wLtt2Ft6ffLpfhNO2v/+tdTEMagCx3ddAv7vYNVb57wfK8GoMhaOampY+thOw", + "e86UK2DSAgd0MFBigjGiubja65u/N13FG9d22Kn+8vK9EoU9uWcufA59pNp2bDzMNQW7BBNFA32+pHzA", + "J1Uzlp7QfrAzvpXKcHTaYewjO/AZRfOrpALynf2igxMfetpH7nx6dCAXWCN+sn3e+dlSxli+YtrQVZXc", + "O6PtzuFbAO+K3b7QxRJMzXIpCm0xKGeEVVIv92UU0OmpNgImK7lGXiemzLlUmH0WeFcjO9HeY7dkZ1x7", + "G8ZMSWmGALVwthISSGkIrc3SPmE+joBBrYDuSjD6DeRWEQU9kdeWy/B5e2lZbqeEmy9wHOU8OylZMXVV", + "MmIUY2S9lJqRktFr1hQVgdG+0OTdhhcaSoaUbMNzuVC0WvKcSFUwhdVmbHOQpbGTm+/RGXFRvS4O4t1G", + "wPJCcYN4nbhMH70SLFrxiqfIwnV/hloPmpXXTJ+Rd2uJQOgmt4G23G+rx6w2GDNY8PmcAfWA5YAoDv2a", + "DxFMUB4FQg3CsG5N908DehiW6SV9/O13Q4j2+NvvUrj29ocnj7/9znLCVBBab3jJqdrGzWyrKZnVvDQu", + "0TYl1yw3UsUaBy60YbTo4RZqo9wswMvMa5E7N7TQJS5i8/aHJ99+9fj/e/ztd059Fc3io6BdgB0T11xJ", + "YT95hWHAEDdlmI1tuDYfgVsyG5GBvJx61e3R5HAsG/EMGxEXeNE253ZI2Ar1U/7il6xYMDVtHmJLV5uc", + "I1a4kyrigOcMQ8Tsu8iFUbKoc4aZLt626EYEFu+BFMonRO42cNd9FaEGTq9JDTwLIS9BAn6EApmQ7RXC", + "HWPXTGFMTzPQA3wcIri0oQr8lMBtyS2VFQ/TT3tdLRQt2DgvBHisfsYeIXGDH+FaHjbAL7Z9V8BqyQAt", + "zjrNwEaBHJZHid/c1Juzg0oMym9vhiIoX2BlHsVKDHWDyijQdtqTzuaMZZYRTGK8lZogAVees8pielyJ", + "kjH71uBNh7sMFfI80xaCoDEIL63BApiynJZ5XaIosYOFXOe0BEtQg9glmxtpcS+utNWYAridawYe4lhS", + "BOdT9g2LekDaqGumtq4Fal58BQ97b1THdafPKmclu2ZlEnBGFfAOP8g1WVGxDWdhp2jAmEaRcQFyZILB", + "QwRP+2enFIrAx3vmEHI3kPYoBja3iM+5YorLgueEi38xd9Fj0QEwBksBSWG4qKH4k2IN3PjUEwjR7Ybh", + "9jFAJV2KLVzUMAtYE8Uh2Lp12kUkKLSDIbShVwzB9sHEjrsZe6aKaV7UacjmiuZtyA5DRnd531DDzlU4", + "Wn0kvOwQr3DJd126Li530KZzWv1dGqRTLbo8hljREPFFHA1POIu7DFS+5YDGQBoJj3aUuyWMfc2Ubrsh", + "R2YCttkztm3RGh/zcvnUBofPknl/ND043xbJcYNznn/GwHvo79IqpHZwIGlZAECvucmXWSpwxAGALSwM", + "b7oifH9K5C7gFrL5nOVmDAwQtYMVsQahwM8WiueMFhAx3kRdYbxVF5QHP0pih9YRyyM0B0Gi4XhglIcH", + "JDQPGLIP+X+RI3HfBdyDJ8SIa+B5HHf2yS1zbRzyvAxR75RsmYZdCd7l0R2BzCRpE6+ftGAl3e6aEhq0", + "Jw08rzdu45sDCTzsg4Le7INByH5qd892TW6bdBccrmf/VsSldnonKRNObj6XZgihclkJEz6bSRuWRWa6", + "AjT25WqnZNYySNy/UfE4aTHScY0++KS3DfDF7wP80d2Ij2xd8WV23TuJK/k1jShRUtkkyhThexQSjXEG", + "sH6ffI+6KrIjsaljyfIY9QnsW2qf/npNy4FAyzesUkyDnoCSd3998so5xQyFW+bpSMfLy/fUWJyCfmQw", + "2dSH6WQgM8Tl5fsZUEzM+xBOo29dTPpQW0LEbXf7udf7Zi55Q0lUow31vvh9gP7mA8BIRblz9GpiTfs7", + "64KO+9HdY4LImgPuLsJF9Q5eoR+oXr6guZFq28/gakXrgdQ6l5fv7XkfssVffZcm9xaE9CTvovw9bRVZ", + "8P8D3zvPD8l5L48PgUQ+S+o0Z/5PK+lHSXvC98l00tMDNGcR5yFO+Bkt4TPmNiS+klv/pAfTNRezLISN", + "pCo6Ticu3XKcY3ZvKBjX2YovFLA86VGH00RHT1TihUFWO1EW2bE1w7x4B0lbC+9A3IAXvQhu5hRCvxQF", + "2zDVWGZeN6vrWMpRfQSFgXXWKFPTtAmR/X75A4zDt1Now4od2pr5gVcRPX5Ky6aNGr+82fgiAzZZZGvG", + "F8v0xv50o6EtG73/0K7v/9BSBO41aP2f2AsJGDlAaOcNGd6ZDD2i2OAbYAbs92aJy/9UQlIVszJMNQCu", + "KQ5EhP8c2OxuZaEEodZ8VZXo/OlISS/31UGJJpoAk7uPVzp20Medh2+wG3skHj9q46aw7E9JtTtW4+/i", + "mVxVJRtmnisqkH2ec+Hk9vWSmriYurcByTyvVWPE7UZj/EJLjlV+NWQxFFJWkLawMlzY/0ACB1kb/D+j", + "yv4HnYra/0OsivgkO9QEzgWSX/mBfCTnZDrBzhOP2UkuKumY1NuUdjorf57ghA22NMFYAQEJTTbpc5ob", + "tH86Z03BzFqqq4QYM9OgT2r5VcVlX/vUlCpTVxRFFBo8KFwK15AVLoDmINO1Ru+alv/EXlrJNpXFtcMB", + "LNTqeiSEYfOkuGbK2T6kyymJVg5MU9tL2EQceIesKUWqb5gAaJQbSl9CS2xzwySiajDt2wRqLRXLyZGv", + "UN9lM1fbyshzaANNzrVRdW40em02c/aw0m40Oi/tr5/XZSksJyA1R3umkZli14wOqenBVYv9VjN7yGCq", + "s41JGCB1sGOJdnePcez01gIgsSsMBk2hg1259ckyqd3zFa3e4yy/koy8QYhDKQXwyFvpRXW45xYOlQJd", + "09Jkg1KO4y/JW1qamI2wADk/j+AhM5y4FjnY5Oj5xxA5LEw3R0G7YFbsYvfXN2D3B2kHzBseCuTA2lfq", + "mimMhR6NDr/4Hh+mk3tdx5twY/tUIVrfuFXEmxKRhrSKxX/116lJlUxFQaL5NYG7kfAVhKvLhFHbm6QZ", + "4otMl/KA5b3li7e2w54t9c16e1rKNVOZnXfHEZfe1IjxNtiylUo61HLB8dBTghXELkbfbCNw4IN2wnXZ", + "vxfN2B2nFFrmUmSt2e+X6iC9zAC7spDlYM/u0VV79yovWx9KtYBIbLlYpDM/WkJ/xbafhi4h4XHcO08w", + "8Q4rc0DQ+DE4NERGprUzIqORsM3o7KkiYcU14DRduZwd98q071XjX7TiuZIUnDGalNOsx8E6YQ98GcNu", + "7HIwSSuXMTE3dn63rVhwyu2X2lnRystbIIdbJvjsLpVW5E1wR+57lOZSGMqhoE6SuUdnXFZWQKga3fjZ", + "J4W+v0Qvc8fXZPf+5CtAoMhwFftv2//3t8woxu7fw/WKbbOSz5nhAwbpcm5X8je2Jb7Z2dF4iqEcSS2D", + "H2geSowJaPI+EanwywK+xOmlCNJRCJLW/i9NCmaYWllUXMo1WdX5Enh3umA+wRIYbMCzvDNRa3SfkaKd", + "HszFB+qK5jgQhv2XVC2YIi4SP9Ql8QagFeVwTxpv4G58LjiK0ZQxbl/ap9eYCiCiXWA6jXJAJbJLeTCu", + "2PYcLYPw+w0IyXAqqQHAIK/UHYJ0q/RUcU6zPfh61TKqYrGvVvK3AP4RjasWPqdCONC42s/WNnZ5sA64", + "DrVm/XWOj8aJ9zYh4jZrG+sZ0N/cAYP+Pjv+QMkWZ+4FOg59CcBH/vnVP4lic6ZAb/XllzD8l19Onb/C", + "Px+3P1ts+/LLtFNT8uYcz28gVAKwY7jpktjRLgDbsaHiI68xnBYd1+yDJgW4bJZlJ+RJFASSDQB7QiEC", + "hJWyYsnWUKwsfkEhAZxii7qkGOrDhWCq1WlMph8U/81GOFUX/PluI1JtY3YSWkfbkSoQGlVhvlnl3E45", + "OcyzlENGo5uO2OREakbE7Cq3GfEFpnQJI/oI09uM+c6NsaeE4+Xle70QoJbzyjjuswQAA4wn3MamkDnA", + "l3n0mYpCOBv7raalC9cTEBz3DtL25FdMYAVHS+Vc9V3ChK6VUwlaWGE8C4obRsaPuW6a3LSW43BBsMvL", + "9ypH7a/zaHfJICDzFHa1bEZhD0fuLqpi21sRcygZneVsqZ3LNfTxxeAruk/0AjRWq2EbfidbdBxZAhkX", + "ff+B4Zv6JU0p9HQuwiapZOdlxvz3D14+f0h4txh6nPUxErT2LzsuoTIOIsww0oOlm3vyECjmjA2F83QC", + "C8mcDaiCd5bvsGOBVIh1PKBV1wV7L5Qjsyr8QDVU6XDNm0j6TzGVQgtI8vJ5ks9oZcc9uCTEdLJQsk5H", + "bi8UmIa6vqBWCAAGCwV4dC47f/ztd6TgC6bNGfkHJNfDx7dfF619moQ39dZapTwJABYStCIb5IIRozmX", + "7kB7wcHcBSXCMPd/wjfJTz6dAF+SmU0qwP1lj2chlYvghNyiEb1pub0fI6ydC6MoEt9MzufJfLt/h98b", + "twjlabJi/VMfQZWv2Faxm/Iuf4POocToMOUpgfJArZ2bEZ6S0YHIgXKTuD5fP86aG3RGXtnehIm5VFaq", + "XtVg6WMbSMznDG4xlwrp60xTHhoy14nfmZKgNBBEOsN2946FzYYoS5oDP69dFLGFISTWDYrJB2+Bm5ki", + "kA9RJu1fNVILw5H9sdv4S7SLlX14LND/WPIygQWVtN91DMeUCEkkOAfFLTGtQZN1EWF2YeEtRLrfax6n", + "Ey/Spn6LCRAP+SqqrdFoJPIlFU3F9v0lGfo4Oa4mc68oUeKapytG2AUscAGLo8D5cR31hBwID7UfgA1R", + "DDMkBu3ZPScDotsVE+aGlO8n7I2+CVDPVu2WANSABOB776sDfMW2mZHpsRkalpAzD6IW6EmR2kZrnA7I", + "PSHGztfAb3hXvEGWRZjXYNCNTJdeT+pEuuBPdsW2jbdLXCsQxaYbSFn4LKa14O/4ijVyCTJyKRaIj3oS", + "UbxMy7WYEwlJ9hc7lhOG2Y0VegArsO9unBht543QNjL09vIc3eAWRG5IkItjR5jHtmLtwD5wTAyKulaS", + "C9AZnJHnIUkM+CFirH2TOQb1WV1vRcyIErIkc+X1XlR5fTU4NIKzG9yaBCFwDZA3sm36XJJrQvM5NBhS", + "BPlmmzlTTbuUMsa3nKvfm4Z9PZBvVlXgWTCg0XKttKnAODR00o1TZkW3E88MTqYTuyz7jwXb/jtXv9t/", + "qqqEKqfVvO+Tmb7ADicymCcR4j5pS60tRjLcxAa19mhAd9bRc4G7c6zBG17VQ9WTsQId05E3PzyjZflu", + "I5wfYD/sbYfnJa0w9O2V87gMFNqScee+67VWjjrElhia55bFK5qUDxGcX2jSrZuCiSD6lVN2eGPupdBd", + "FiDGTaoWg+sGhVWfDeU5oWpRY/qhe1jfnhUMSDa04oVLyNgvZOdYNiQLtWIFkcql8uJzl6dtqJLD/jJV", + "uHuV4xl53rCGTRaKAUyfWuGHVS7ZuhRZHjzL7TtpJUwjySV6ZF9OzshLzBmjGC2QwCpuWKqOUmv9kPx2", + "zaCss8foLJxuVAXvzN6iVs0tDZitGPhPJEqkfZb1uODEdD1wYkNUCbmq9iF9hBN61i8mBsUChDSf0TmN", + "qsx1efmeVXCx2mUv4jiKqgrFukpm9/23GgLgLMGGYQd0tFIxvhADtdgBQebUPwS6e1zJ56BNpVy6wfjg", + "de+VCOz4zYgoWF5wMEwhQIsMStnvcPlOkNewFwPF4ZHAhWSTuom90W6VUQ2McUv0ZOanaIWA2J6VPeb6", + "blBS7dZ11DoDtKjGvr6tAKNE5bX4LewOvY8zi6ycOzkzLNlQ2oUjfVIs8++np1iiwGoOdROvdCmekN+Z", + "kk5YDUPZC9Hoxl0acJcf9SzRKRRW0b1u3SkPLFiDi9/BHQ4WgLq8fL+hPS4DYLoFf3GzGl57z/jFQCmR", + "+Iy9qczVELllJSCcccfGNjGXfYsYLWBfo/oLsY8XEplQUAB329VUAWSh64EyJjtPc77zNHeM38rAtPbS", + "IaYfTpNPJ01irqu133HskYrrHI5RbCpK9acec/mD88Ao1PAS8m2Rw8+6Az2GTemUopfoEzSiW6lMO8bL", + "w3dGHAlJJ/LWrJx7auZtc956HGOafZnwXVvR6qjV4/YSjwjiYZ8DNuhx0OQ1cw9zIpU5jtD4Nlhe01sj", + "EyzjgWv3o6ePEL5201nRuCqEXsq6LLAwxApysTUyZuJ0XAGowBc2BbnQjQO8LuIgax3NEG82IS/tyLRc", + "0632itoGs4aH87uK5SMSSsI4WSNql9N7o3J0E2c5rzgTJvjcxOdikXxYvZke2KlJLdXBLHL8OmgtnOM9", + "bSqptU1v3vLmqkXR6IWeum2mZVtdgAN7VbRt88yP7VcUjjR60PanFEnV0wtbuofoOdvoTmrn9IqHEjns", + "hVQOpxkmb0KKdgDwgFFG2Eb20F5TddV6BN1ldQOIBaYTaI3a4jGiJACalZiKtBODPBQho1npTBk/1bOS", + "52BGAKfvYFhwHv8FeUNFIVfkhU/m8+CXNy8eEsV0XRqPZD6zsUU+B8nHLScwuPBKzd3K30bRMmH5XDiL", + "yoJroxKKy3tfFeR83OdwZBvNtWm8jtBgjekeewHh3FHB9DMEE16xbVbwsh5EZNvqqmgn3NT1DMrCcYFZ", + "eWfU5ODN0gNB75h6j4eDbVPiUsHN4bYrHXdhYLnuxrRmqTr351NDoD2ihDev7qaeznJzKPl03ZB+uplu", + "xh8ie9iESUSJgO15+oIonYf/VlxWNAXGaVnuQ7uqhA2z1XYpbYp+iuAZGhkS9rqctsdLu516PgsmgcJn", + "vM9x2Qnh9XdvS8MZQf/CFSstI+ZnXotCd7awKYe/w/66k/dxrI9vs9OUO8QUjOUEWkGzbUjAcOmCTpp4", + "aa1lzhsjPNSaxKqSfxfl1iWl61b0aLayUvKaF6lC9KVc8FyjCuZQi/Er3/fDdLKqS8NvOM5r3xdN2Onn", + "kC/cUygKqgrCisfffvvVX9qpED4hctXfpKR7j1uW0zJSw/M2HxtWN4KI+aM8W8g+yRo0tqlFY3sIxrVU", + "4tbxNjIAZDj03StanYPIbEtohOrSsu2l4c1PU/vbkuplQzqjssVQRpoSR6+6Xn8QXxQZ+u45/NwhdnYr", + "x4zO9RgiHM0l+RTuRkweER/GksTXESXprXDlloh6V4svPugS9roqmeXtGho4mEbHHw0++X7Ot7xf5T8e", + "L73r0ABKB0rLiWBeVstMNhwXKAgaqG7gHdzbn7cxXKm8eEvFtIUo7X2zVMlMI7vybzaZDxN51Q8627ed", + "Pe1kJoF9G+Rwq6uPlMBmFw58Glkc0o5Yu1nmoVwMZExgXkhG1U1CNcw9R1lhd6H+YL7Vtvw8PqOJA6fr", + "5TbknqYr76D2LgodjTN0kZeI/o1XI/CxAvPVuJR7aPx1BQDa+3X7kPwPECEwl5jdQBiamya1+OSJG2ni", + "ivxOlsZU+uL8fL1en/lpznK5Ol9AlFNmZJ0vz/1AkEaylTrNdXHVr+yzW24NzzV58tNLYJK5KRkETMDR", + "RQl1LyaPzx5h6kUmaMUnF5Ovzx6dfYVXZAl4cY5pjicXf3yYTs6vH5/HzlGLVODDW0ZVvkQ0dm3PII0g", + "Q3H2ZREavZDqiR/OGbrARjy5eN/LEAeqVQgT4fbv32qmthNfGD3W+zXm1z493B9Aj3opjR6/plaYkkAx", + "knuuPfItAPcBwq6ZIBwxseQrbrxKVDGaLx2bloAZ2h4IcFMLhS5YBO8Z+VmzqBaZvIKYI5QvfASDL6UV", + "Og0AZodIwdXQuH70OO6ak23AAZQKb2tZQJQdmMlE5Kl81irm43TzvvwdZjvNt6QWpWUovcEJ7MQ6LA3q", + "PGE6m5y6HXDhfd5NWg+fgJ8kcxBmFsIDT8TV1QZhGLgH59gNak0nKzscn4bMrbGnyBQN1nILue80s+1C", + "LtSOSWHqPD3ssPg5ckUCHwT0IxlasPM5z2hZppYZWRe7y/zrxi2zwX5cra7zJfgkdQHtQobZPF0mihBQ", + "5PZm6vpHfiI+NjP4h4SWorWBI/rY7WCbqpQFm1zMaalZensYLrK1NYEj9B64uHfOFaYTlarR+VZnkT/I", + "pBVRa1sIKdK5UnspCc0WSLd9dCaH3jq4Np/ulbNT3Oq+eb/byKnCyCa0HDKx2kvosjclX40QGz9M7fZ6", + "0+7+3AX/ueVKckBScI/hmpalXLPCVfkMyByKHrg7G14mxx86u6aLLTsjb9CvTUfxIM1Y4KujGBFy7VwA", + "h08olFY84FDi/K3Db3TXMWnHDL9aWRVLKsDle/zokWennLo5Gu38XxoFo2bAYYfuQ8LDUnfSV6faGXof", + "ao6iHRQPbo1sxKqqzbCzyMZk8Hj3R/5ZO7pZ0QUXzsUKlLgreoU8LgYKOg9Hf2F9pgXLEQTrnOMhHH6M", + "0KU2bFp7A35Nsr9tyB+Ap9NDu8BvbnWOg7U0hmtadNbhG44B+41DQPTSxlocH6aTbz/3JVikpgsNpVCA", + "DZ/8+qHD3J//4V2MefFhkNN/JeVVXQUbQVSvqs/wY1t3r55ugUjsZPiD5cGTYSApUP+goSgByEm8R0bV", + "7CD29d+TKJ840xNnej+c6Z281ge80Xf4JqffwdMzOPnm0Tenl/zTeclLeF/3vOTnPQqw72kXkWtll47K", + "CsltuW0/f7nLzbODAXhSVZD+AfTA+lNiBY4uyfxZn+WTavVGqtUjP6Wd+36ABNzM0tzUkzwcBVl1NvbE", + "EZw4gs+RIwghnR+FD/Ciyafz/t+JnfH05p/e/Ht788ONHvfQx9UzT++7f9+DEuX0qJ8e9c/tUU9kcD7s", + "iffayrQy81ZP/jMc+kkM2kn+P/ECJ17gbuT/FgE4VPQ/MQSJrContuDEFnzebMHhMn9gCDq20KOwAicl", + "wOnhPz38H10JcHrsT9L/6Zn//J/5OBZsrO9eO7XPu1axOcUc2WYFEWxtL5uRRJb2MdrzwscD7XvgT+/G", + "cWJxogpYdpY53zjq7PMuuYrCTT1QIQ3D7OuDUECmExjsYFd5jFkf8pQPX/9ITuzziceTHi8Vemr3+AIi", + "C+e8BL+9f9lN84hYNwk5gqenz4wfIlEha73mC5KFvAj2lxX+BLG2b/nC/lTiTxDljzHOqS3QfDG8Bxq6", + "rfAfO96oRbrLHy2kneBgtnXMe/pI0pzv8HQvE86y7U0M5byP7fvqp6SGWOFkjmFo8dQrLrKd04cGRwFh", + "xubSxd1EMNDNHhh8g0PjMu5UkPEri9a04JYAQ21r8trRGyrImxfPyNdff/0XgvfeCjaILkMLxiGxikgM", + "XKAbBTXh8xgq9ObFMwDgbXBpHdVq76EGjDrWymHET2/hf+IIzz9lmN19qlu6lwpX7UMsUKjEskq7uZRQ", + "fGmnwuK4gvafRECeTrpSxe3rKHYEpfZOdiY8hZn9W8mtY+zScR6JtvFlKJXEASbluzfzvgABAuWHVmGI", + "cOmQYwjZgZu0dkmCjs1uxnifNM4nzcHJ1PxnNDX/WwcrR/t0/kebWO8PWo6qww3pMJsm6YDlFEvcfTL2", + "ssV/OoPhnZGdA4nN/QWN3tKKdDLBfCasbI8Inc/kZpAQ/T/A/lnpv8WLwjWcyQ2x92rq2BfdyfwaGkBr", + "p3N46n5riv06/f5CujpouaUkVC2wnPMXMBgXiwsY4Isz8kIqwoGa1I4PwYZcmIuvHn/9jWui6JrMtobp", + "qYMHoCPffQPQ2K5fzL775gtvfaCQ0d3+dPHk++/dGJXiwtBZyZyGoTenNupiycpSug6OP2a9hvbDxX//", + "z/+enZ19MYaUy42l5k9E8SNdsfsn6k+as+MCjiY76om0293XpicZUNzf8Yqh274Mu4j/U7lJXXd7Z6K8", + "JSez/enNON6boevViqqtpfXMwLWPUM15y6ESoMON3vixYfrQ56Z5YaAie3hCILMqbXOBWirLYZZsw3O5", + "ULRacvuibM9G6WSeAnj3Tm9PyoFPSzkwXJ+54sWmUyqdcFGwTVp+D+g+StPwVG6euyllsgbo56AOwNuA", + "Cx9DmJ7G17l99U8v3emlu8uXDtFuxBt3kFbnvJQLfYBqh9j2I4SCV3KhP46O5/Q8Hcfr7SO7NP1J/Yug", + "zFEw1PdK4WMiXle7ard9C1tlTR3bu8nH++mzNXdq8yjlIvMvxuFpgBbPbdfPmne6hSp2lxJwd0BVbMmG", + "lrsEplHBUCfD7ulxPOC1avkiYIHke/RC2D+7HX2PFvGo89WCm6H57LfJ/UcLnsK/TuFfJ9H0Pr0H4JDP", + "//DXc7/HAFzzMUnObcPx0mRcsfzkK3CnvgJA5sbSwntMKg1TnsjNSZn3abs6dCnm+YyWVORsr0YOWW9t", + "QA3t6/aslxIIisuHDwRmJ0X1k51ko5NsdCpddwpsGhvYdDSm67jcSEw8R0lpr7ngp2ydqVdv1jwNJ5Ht", + "z8SAHJLqomWeAF2so0+78l1glgv7pGLmi50y3ynbxSnbxSnbxSnbxSnbxcexRp/yUpzyUpzEt3/vvBRj", + "PE6cEdMCKgVDV+ZWY3z+B7mQu3ZC6S3qmVzNuGCNAORX0BQLNdIeFDRaUhPeYd/QSKKDl8GedWVKlgPv", + "KzjhgFCcM34N/50rxn5nmaHKMtdj3tvWajyAUBozmj+ujXnQ2ixTjAo34vOBaFdGVa0gDa0JuWoJJX4l", + "U8snb2VN1nBZSn4F/V1dTbvpKyjI2qnRaiQxqh40TrvuGcCzN/PI9D4MQKckKqckKqckKn8CbcislPmV", + "Pv8DjjpDPcJeIzZ0GlJiPLUf9yku8DLidOm0UDFAtyRqPzBaMEWkffTnJV2ckX/Yywm3D1xLjafQ00Zn", + "A2skhWSoC3EKgC4PoAfo3xKmzOyUd0sCd0arwEmcAsM/4+s5SjUZeYaOzcDb1Uh6dj3NNnIN7HiXaQ9i", + "4mG5fYOX6knTedJ0njSdJ03nSdN5yut70p+e9Kcn/elJf3rSn570p3euP/2YOs+7rxV60qqetKontc1H", + "DQuKj/b8DysT7Q8MIlZ8LFsv5JCKNca6MdFBTii7vxxq90hCou066LKOv5ynGJoTeflUtMIfphPN1LW/", + "67UqJxeTpTGVvjg/Zxu6qkp2lsvVOSSpcP3/CHy/XK3goQq/uJGjXxwps903mVTcvr1lptd0sWAqszMj", + "zI/PHk0+/J8AAAD//3BbS4jifQEA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/generated/v2/types.go b/api/generated/v2/types.go index eeef46d88..36d8da56d 100644 --- a/api/generated/v2/types.go +++ b/api/generated/v2/types.go @@ -1499,7 +1499,7 @@ type SearchForAccountsParams struct { // AuthAddr Include accounts configured to use this spending key. AuthAddr *string `form:"auth-addr,omitempty" json:"auth-addr,omitempty"` - // Round Include results for the specified round. For performance reasons, this parameter may be disabled on some configurations. Using application-id or asset-id filters will return both creator and opt-in accounts. Filtering by include-all will return creator and opt-in accounts for deleted assets and accounts. Non-opt-in managers are not included in the results when asset-id is used. + // Round Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected. Round *uint64 `form:"round,omitempty" json:"round,omitempty"` // ApplicationId Application ID @@ -1511,7 +1511,7 @@ type SearchForAccountsParamsExclude string // LookupAccountByIDParams defines parameters for LookupAccountByID. type LookupAccountByIDParams struct { - // Round Include results for the specified round. + // Round Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected. Round *uint64 `form:"round,omitempty" json:"round,omitempty"` // IncludeAll Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates. diff --git a/api/handlers.go b/api/handlers.go index ca1333535..78f15ef7c 100644 --- a/api/handlers.go +++ b/api/handlers.go @@ -17,7 +17,6 @@ import ( log "github.com/sirupsen/logrus" "github.com/algorand/avm-abi/apps" - "github.com/algorand/indexer/v3/accounting" "github.com/algorand/indexer/v3/api/generated/common" "github.com/algorand/indexer/v3/api/generated/v2" "github.com/algorand/indexer/v3/idb" @@ -29,13 +28,6 @@ import ( // ServerImplementation implements the handler interface used by the generated route definitions. type ServerImplementation struct { - // EnableAddressSearchRoundRewind is allows configuring whether or not the - // 'accounts' endpoint allows specifying a round number. This is done for - // performance reasons, because requesting many accounts at a particular - // round could put a lot of strain on the system (especially if the round - // is from long ago). - EnableAddressSearchRoundRewind bool - db idb.IndexerDb dataError func() error @@ -196,8 +188,9 @@ func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID st if err := si.verifyHandler("LookupAccountByID", ctx); err != nil { return badRequest(ctx, err.Error()) } - if params.Round != nil && uint64(*params.Round) > math.MaxInt64 { - return notFound(ctx, errValueExceedingInt64) + // The Round parameter is no longer supported (as it was used to request account rewinding) + if params.Round != nil { + return badRequest(ctx, errRewindingAccountNotSupported) } addr, decodeErrors := decodeAddress(&accountID, "account-id", make([]string, 0)) @@ -227,7 +220,7 @@ func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID st } } - accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options, params.Round) + accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options) if err != nil { var maxErr idb.MaxAPIResourcesPerAccountError if errors.As(err, &maxErr) { @@ -385,13 +378,13 @@ func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params gener return badRequest(ctx, err.Error()) } if (params.AssetId != nil && uint64(*params.AssetId) > math.MaxInt64) || - (params.ApplicationId != nil && uint64(*params.ApplicationId) > math.MaxInt64) || - (params.Round != nil && uint64(*params.Round) > math.MaxInt64) { + (params.ApplicationId != nil && uint64(*params.ApplicationId) > math.MaxInt64) { return notFound(ctx, errValueExceedingInt64) } - if !si.EnableAddressSearchRoundRewind && params.Round != nil { - return badRequest(ctx, errMultiAcctRewind) + // The Round parameter is no longer supported (as it was used to request account rewinding) + if params.Round != nil { + return badRequest(ctx, errRewindingAccountNotSupported) } spendingAddr, decodeErrors := decodeAddress(params.AuthAddr, "account-id", make([]string, 0)) @@ -440,7 +433,7 @@ func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params gener options.GreaterThanAddress = addr[:] } - accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options, params.Round) + accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options) if err != nil { var maxErr idb.MaxAPIResourcesPerAccountError if errors.As(err, &maxErr) { @@ -1391,7 +1384,7 @@ func (si *ServerImplementation) fetchBlock(ctx context.Context, round uint64, op // fetchAccounts queries for accounts and converts them into generated.Account // objects, optionally rewinding their value back to a particular round. -func (si *ServerImplementation) fetchAccounts(ctx context.Context, options idb.AccountQueryOptions, atRound *uint64) ([]generated.Account, uint64 /*round*/, error) { +func (si *ServerImplementation) fetchAccounts(ctx context.Context, options idb.AccountQueryOptions) ([]generated.Account, uint64 /*round*/, error) { var round uint64 accounts := make([]generated.Account, 0) err := callWithTimeout(ctx, si.log, si.timeout, func(ctx context.Context) error { @@ -1404,33 +1397,12 @@ func (si *ServerImplementation) fetchAccounts(ctx context.Context, options idb.A } }() - if (atRound != nil) && (*atRound > round) { - return fmt.Errorf("%s: the requested round %d > the current round %d", - errRewindingAccount, *atRound, round) - } - for row := range accountchan { if row.Error != nil { return row.Error } - // Compute for a given round if requested. - var account generated.Account - if atRound != nil { - acct, err := accounting.AccountAtRound(ctx, row.Account, *atRound, si.db) - if err != nil { - // Ignore the error if this is an account search rewind error - _, isSpecialAccountRewindError := err.(*accounting.SpecialAccountRewindError) - if len(options.EqualToAddress) != 0 || !isSpecialAccountRewindError { - return fmt.Errorf("%s: %v", errRewindingAccount, err) - } - // If we didn't return, continue to the next account - continue - } - account = acct - } else { - account = row.Account - } + account := row.Account // match the algod equivalent which includes pending rewards account.Rewards += account.PendingRewards diff --git a/api/handlers_test.go b/api/handlers_test.go index 18c152698..c5b2e40da 100644 --- a/api/handlers_test.go +++ b/api/handlers_test.go @@ -9,7 +9,6 @@ import ( "math" "net/http" "net/http/httptest" - "strings" "testing" "time" @@ -664,7 +663,6 @@ func TestFetchTransactions(t *testing.T) { // Setup the mocked responses mockIndexer := &mocks.IndexerDb{} si := testServerImplementation(mockIndexer) - si.EnableAddressSearchRoundRewind = true si.timeout = 1 * time.Second roundTime := time.Now() @@ -740,26 +738,9 @@ func TestFetchTransactions(t *testing.T) { } } -func TestFetchAccountsRewindRoundTooLarge(t *testing.T) { - ch := make(chan idb.AccountRow) - close(ch) - var outCh <-chan idb.AccountRow = ch - - db := &mocks.IndexerDb{} - db.On("GetAccounts", mock.Anything, mock.Anything).Return(outCh, uint64(7)).Once() - - si := testServerImplementation(db) - si.EnableAddressSearchRoundRewind = true - atRound := uint64(8) - _, _, err := si.fetchAccounts(context.Background(), idb.AccountQueryOptions{}, &atRound) - assert.Error(t, err) - assert.True(t, strings.HasPrefix(err.Error(), errRewindingAccount), err.Error()) -} - func TestLookupApplicationLogsByID(t *testing.T) { mockIndexer := &mocks.IndexerDb{} si := testServerImplementation(mockIndexer) - si.EnableAddressSearchRoundRewind = true txnBytes := loadResourceFileOrPanic("test_resources/app_call_logs.txn") var stxn sdk.SignedTxnWithAD @@ -1119,13 +1100,6 @@ func TestBigNumbers(t *testing.T) { return si.SearchForApplications(ctx, generated.SearchForApplicationsParams{ApplicationId: uint64Ptr(uint64(math.MaxInt64 + 1))}) }, }, - { - name: "SearchForAccountInvalidRound", - errString: errValueExceedingInt64, - callHandler: func(ctx echo.Context, si ServerImplementation) error { - return si.SearchForAccounts(ctx, generated.SearchForAccountsParams{Round: uint64Ptr(uint64(math.MaxInt64 + 1))}) - }, - }, { name: "SearchForAccountInvalidAppID", errString: errValueExceedingInt64, @@ -1140,15 +1114,6 @@ func TestBigNumbers(t *testing.T) { return si.SearchForAccounts(ctx, generated.SearchForAccountsParams{AssetId: uint64Ptr(uint64(math.MaxInt64 + 1))}) }, }, - { - name: "LookupAccountByID", - errString: errValueExceedingInt64, - callHandler: func(ctx echo.Context, si ServerImplementation) error { - return si.LookupAccountByID(ctx, - "PBH2JQNVP5SBXLTOWNHHPGU6FUMBVS4ZDITPK5RA5FG2YIIFS6UYEMFM2Y", - generated.LookupAccountByIDParams{Round: uint64Ptr(uint64(math.MaxInt64 + 1))}) - }, - }, { name: "SearchForAssets", errString: errValueExceedingInt64, @@ -1230,6 +1195,53 @@ func TestBigNumbers(t *testing.T) { } } +func TestRewindRoundParameterRejected(t *testing.T) { + testcases := []struct { + name string + errString string + callHandler func(ctx echo.Context, si ServerImplementation) error + }{ + { + name: "SearchForAccountInvalidRound", + errString: errRewindingAccountNotSupported, + callHandler: func(ctx echo.Context, si ServerImplementation) error { + return si.SearchForAccounts(ctx, generated.SearchForAccountsParams{Round: uint64Ptr(uint64(math.MaxInt64 + 1))}) + }, + }, + { + name: "LookupAccountByID", + errString: errRewindingAccountNotSupported, + callHandler: func(ctx echo.Context, si ServerImplementation) error { + return si.LookupAccountByID(ctx, + "PBH2JQNVP5SBXLTOWNHHPGU6FUMBVS4ZDITPK5RA5FG2YIIFS6UYEMFM2Y", + generated.LookupAccountByIDParams{Round: uint64Ptr(uint64(math.MaxInt64 + 1))}) + }, + }, + } + + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + + // Make a mock indexer. + mockIndexer := &mocks.IndexerDb{} + + si := testServerImplementation(mockIndexer) + + // Setup context... + e := echo.New() + req := httptest.NewRequest(http.MethodGet, "/", nil) + rec1 := httptest.NewRecorder() + c := e.NewContext(req, rec1) + + // call handler + tc.callHandler(c, *si) + assert.Equal(t, http.StatusBadRequest, rec1.Code) + bodyStr := rec1.Body.String() + require.Contains(t, bodyStr, tc.errString) + }) + } +} + func TestFetchBlock(t *testing.T) { testcases := []struct { name string diff --git a/api/indexer.oas2.json b/api/indexer.oas2.json index ae495ea16..76c11d21d 100644 --- a/api/indexer.oas2.json +++ b/api/indexer.oas2.json @@ -80,8 +80,7 @@ }, { "type": "integer", - "description": "Include results for the specified round. For performance reasons, this parameter may be disabled on some configurations. Using application-id or asset-id filters will return both creator and opt-in accounts. Filtering by include-all will return creator and opt-in accounts for deleted assets and accounts. Non-opt-in managers are not included in the results when asset-id is used.", - + "description": "Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected.", "name": "round", "in": "query" }, @@ -120,7 +119,10 @@ "$ref": "#/parameters/account-id" }, { - "$ref": "#/parameters/round" + "type": "integer", + "description": "Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected.", + "name": "round", + "in": "query" }, { "$ref": "#/parameters/include-all" diff --git a/api/indexer.oas3.yml b/api/indexer.oas3.yml index 9611bb81b..9a425b354 100644 --- a/api/indexer.oas3.yml +++ b/api/indexer.oas3.yml @@ -2480,7 +2480,7 @@ "x-algorand-format": "Address" }, { - "description": "Include results for the specified round. For performance reasons, this parameter may be disabled on some configurations. Using application-id or asset-id filters will return both creator and opt-in accounts. Filtering by include-all will return creator and opt-in accounts for deleted assets and accounts. Non-opt-in managers are not included in the results when asset-id is used.", + "description": "Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected.", "in": "query", "name": "round", "schema": { @@ -2592,7 +2592,7 @@ } }, { - "description": "Include results for the specified round.", + "description": "Deprecated and disallowed. This parameter used to include results for a specified round. Requests with this parameter set are now rejected.", "in": "query", "name": "round", "schema": { diff --git a/api/server.go b/api/server.go index 94d19ba32..0f4d402d5 100644 --- a/api/server.go +++ b/api/server.go @@ -23,9 +23,6 @@ type ExtraOptions struct { // Tokens are the access tokens which can access the API. Tokens []string - // DeveloperMode turns on features like AddressSearchRoundRewind - DeveloperMode bool - // MetricsEndpoint turns on the /metrics endpoint for prometheus metrics. MetricsEndpoint bool @@ -133,13 +130,12 @@ func Serve(ctx context.Context, serveAddr string, db idb.IndexerDb, dataError fu } api := ServerImplementation{ - EnableAddressSearchRoundRewind: options.DeveloperMode, - db: db, - dataError: dataError, - timeout: options.handlerTimeout(), - log: log, - disabledParams: disabledMap, - opts: options, + db: db, + dataError: dataError, + timeout: options.handlerTimeout(), + log: log, + disabledParams: disabledMap, + opts: options, } generated.RegisterHandlers(e, &api, middleware...) diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go index d724601ee..ce73ea764 100644 --- a/cmd/algorand-indexer/daemon.go +++ b/cmd/algorand-indexer/daemon.go @@ -70,7 +70,7 @@ func DaemonCmd() *cobra.Command { cfg.flags = daemonCmd.Flags() cfg.flags.StringVarP(&cfg.daemonServerAddr, "server", "S", ":8980", "host:port to serve API on (default :8980)") cfg.flags.StringVarP(&cfg.tokenString, "token", "t", "", "an optional auth token, when set REST calls must use this token in a bearer format, or in a 'X-Indexer-API-Token' header") - cfg.flags.BoolVarP(&cfg.developerMode, "dev-mode", "", false, "allow performance intensive operations like searching for accounts at a particular round") + cfg.flags.BoolVarP(&cfg.developerMode, "dev-mode", "", false, "has no effect currently, reserved for future performance intensive operations") cfg.flags.StringVarP(&cfg.metricsMode, "metrics-mode", "", "OFF", "configure the /metrics endpoint to [ON, OFF, VERBOSE]") cfg.flags.DurationVarP(&cfg.writeTimeout, "write-timeout", "", 30*time.Second, "set the maximum duration to wait before timing out writes to a http response, breaking connection") cfg.flags.DurationVarP(&cfg.readTimeout, "read-timeout", "", 5*time.Second, "set the maximum duration for reading the entire request") @@ -300,7 +300,6 @@ func runDaemon(daemonConfig *daemonConfig) error { // makeOptions converts CLI options to server options func makeOptions(daemonConfig *daemonConfig) (options api.ExtraOptions) { - options.DeveloperMode = daemonConfig.developerMode if daemonConfig.tokenString != "" { options.Tokens = append(options.Tokens, daemonConfig.tokenString) } diff --git a/cmd/idbtest/idbtest.go b/cmd/idbtest/idbtest.go index e6a62554e..b2f6c3df1 100644 --- a/cmd/idbtest/idbtest.go +++ b/cmd/idbtest/idbtest.go @@ -9,7 +9,6 @@ import ( "os" "time" - "github.com/algorand/indexer/v3/accounting" models "github.com/algorand/indexer/v3/api/generated/v2" "github.com/algorand/indexer/v3/idb" _ "github.com/algorand/indexer/v3/idb/postgres" @@ -160,9 +159,6 @@ func main() { MaxRound: account.Round, } printTxnQuery(db, tf) - raccount, err := accounting.AccountAtRound(context.Background(), account, round, db) - maybeFail(err, "AccountAtRound, %v", err) - fmt.Printf("raccount %s\n", string(ajson.Encode(raccount))) } if txntest { From 8aad7bc5fbec01227acb4f085e7546f2a6a5858f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Pier=C5=9Bcionek?= Date: Thu, 1 Feb 2024 22:07:15 +0100 Subject: [PATCH 2/9] Cockroach DB schema, asset/unit name index hints, pagination speedup, indexed notePrefix --- idb/postgres/postgres.go | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-) diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go index 1a6850ccb..5ba34d67a 100644 --- a/idb/postgres/postgres.go +++ b/idb/postgres/postgres.go @@ -647,6 +647,12 @@ func buildTransactionQuery(tf idb.TransactionFilter) (query string, whereArgs [] partNumber++ } if len(tf.NotePrefix) > 0 { + if len(tf.NotePrefix) >= 3 { + // use the note computed index for first 3 characters of the note + whereParts = append(whereParts, fmt.Sprintf("t.note3 = $%d", partNumber)) + whereArgs = append(whereArgs, tf.NotePrefix[:3]) + partNumber++ + } whereParts = append(whereParts, fmt.Sprintf("substring(decode(t.txn -> 'txn' ->> 'note', 'base64') from 1 for %d) = $%d", len(tf.NotePrefix), partNumber)) whereArgs = append(whereArgs, tf.NotePrefix) partNumber++ @@ -1891,7 +1897,7 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions, countOnly b if countOnly { selectCols = `count(*) as asset_count` } else { - selectCols = `json_agg(ap.index) as paid, json_agg(ap.params) as pp, json_agg(ap.created_at) as asset_created_at, json_agg(ap.closed_at) as asset_closed_at, json_agg(ap.deleted) as asset_deleted` + selectCols = `json_agg(ap.id) as paid, json_agg(ap.params) as pp, json_agg(ap.created_at) as asset_created_at, json_agg(ap.closed_at) as asset_closed_at, json_agg(ap.deleted) as asset_deleted` } query += `, qap AS (SELECT ya.addr, ` + selectCols + ` FROM asset ap JOIN qaccounts ya ON ap.creator_addr = ya.addr` + where + ` GROUP BY 1)` } @@ -1903,7 +1909,7 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions, countOnly b if countOnly { selectCols = `count(*) as app_count` } else { - selectCols = `json_agg(app.index) as papps, json_agg(app.params) as ppa, json_agg(app.created_at) as app_created_at, json_agg(app.closed_at) as app_closed_at, json_agg(app.deleted) as app_deleted` + selectCols = `json_agg(app.id) as papps, json_agg(app.params) as ppa, json_agg(app.created_at) as app_created_at, json_agg(app.closed_at) as app_closed_at, json_agg(app.deleted) as app_deleted` } query += `, qapp AS (SELECT app.creator as addr, ` + selectCols + ` FROM app JOIN qaccounts ON qaccounts.addr = app.creator` + where + ` GROUP BY 1)` } @@ -1971,18 +1977,27 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions, countOnly b // Assets is part of idb.IndexerDB func (db *IndexerDb) Assets(ctx context.Context, filter idb.AssetsQuery) (<-chan idb.AssetRow, uint64) { - query := `SELECT index, creator_addr, params, created_at, closed_at, deleted FROM asset a` + //use inverted index hint when searching fror UN or AN but not both. + idxhint := "" + if filter.Unit != "" && filter.Name == "" { + idxhint = "@ndly_asset_params_un" + } + if filter.Name != "" && filter.Unit == "" { + idxhint = "@ndly_asset_params_an" + } + + query := fmt.Sprintf(`SELECT id as index, creator_addr, params, created_at, closed_at, deleted FROM asset%s a`, idxhint) const maxWhereParts = 14 whereParts := make([]string, 0, maxWhereParts) whereArgs := make([]interface{}, 0, maxWhereParts) partNumber := 1 if filter.AssetID != nil { - whereParts = append(whereParts, fmt.Sprintf("a.index = $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("a.id = $%d", partNumber)) whereArgs = append(whereArgs, *filter.AssetID) partNumber++ } if filter.AssetIDGreaterThan != nil { - whereParts = append(whereParts, fmt.Sprintf("a.index > $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("a.id > $%d", partNumber)) whereArgs = append(whereArgs, *filter.AssetIDGreaterThan) partNumber++ } @@ -2014,7 +2029,7 @@ func (db *IndexerDb) Assets(ctx context.Context, filter idb.AssetsQuery) (<-chan whereStr := strings.Join(whereParts, " AND ") query += " WHERE " + whereStr } - query += " ORDER BY index ASC" + query += " ORDER BY id ASC" if filter.Limit != 0 { query += fmt.Sprintf(" LIMIT %d", filter.Limit) } @@ -2226,14 +2241,14 @@ func (db *IndexerDb) yieldAssetBalanceThread(rows pgx.Rows, out chan<- idb.Asset func (db *IndexerDb) Applications(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.ApplicationRow, uint64) { out := make(chan idb.ApplicationRow, 1) - query := `SELECT index, creator, params, created_at, closed_at, deleted FROM app ` + query := `SELECT id as index, creator, params, created_at, closed_at, deleted FROM app ` const maxWhereParts = 4 whereParts := make([]string, 0, maxWhereParts) whereArgs := make([]interface{}, 0, maxWhereParts) partNumber := 1 if filter.ApplicationID != nil { - whereParts = append(whereParts, fmt.Sprintf("index = $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("id = $%d", partNumber)) whereArgs = append(whereArgs, *filter.ApplicationID) partNumber++ } @@ -2243,7 +2258,7 @@ func (db *IndexerDb) Applications(ctx context.Context, filter idb.ApplicationQue partNumber++ } if filter.ApplicationIDGreaterThan != nil { - whereParts = append(whereParts, fmt.Sprintf("index > $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("id > $%d", partNumber)) whereArgs = append(whereArgs, *filter.ApplicationIDGreaterThan) partNumber++ } @@ -2375,7 +2390,7 @@ func (db *IndexerDb) ApplicationBoxes(ctx context.Context, queryOpts idb.Applica if !queryOpts.OmitValues { columns += `, ab.value` } - query := fmt.Sprintf(`WITH apps AS (SELECT index AS app FROM app WHERE index = $1) + query := fmt.Sprintf(`WITH apps AS (SELECT id AS app FROM app WHERE id = $1) SELECT %s FROM apps a LEFT OUTER JOIN app_box ab ON ab.app = a.app`, columns) From 215f3e5c2395152a8e8be56e54c1face46d74c0a Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Thu, 29 Aug 2024 19:03:00 -0300 Subject: [PATCH 3/9] Use a schema for CockroachDB instead of Postgres --- .../internal/schema/setup_postgres.sql | 198 ++++++++--------- .../internal/schema/setup_postgres_sql.go | 201 ++++++++---------- 2 files changed, 181 insertions(+), 218 deletions(-) diff --git a/idb/postgres/internal/schema/setup_postgres.sql b/idb/postgres/internal/schema/setup_postgres.sql index bd2e3242e..72e1a4cee 100644 --- a/idb/postgres/internal/schema/setup_postgres.sql +++ b/idb/postgres/internal/schema/setup_postgres.sql @@ -1,127 +1,109 @@ --- This file is setup_postgres.sql which gets compiled into go source using a go:generate statement in postgres.go --- --- TODO? replace all 'addr bytea' with 'addr_id bigint' and a mapping table? makes addrs an 8 byte int that fits in a register instead of a 32 byte string -CREATE TABLE IF NOT EXISTS block_header ( - round bigint PRIMARY KEY, - realtime timestamp without time zone NOT NULL, - rewardslevel bigint NOT NULL, - header jsonb NOT NULL +CREATE TABLE public.block_header ( + round INT8 NOT NULL, + realtime TIMESTAMP NOT NULL, + rewardslevel INT8 NOT NULL, + header JSONB NOT NULL, + CONSTRAINT block_header_pkey PRIMARY KEY (round ASC), + INDEX block_header_time (realtime ASC) ); --- For looking round by timestamp. We could replace this with a round-to-timestamp algorithm, it should be extremely --- efficient since there is such a high correlation between round and time. -CREATE INDEX IF NOT EXISTS block_header_time ON block_header (realtime); - -CREATE TABLE IF NOT EXISTS txn ( - round bigint NOT NULL, - intra integer NOT NULL, - typeenum smallint NOT NULL, - asset bigint NOT NULL, -- 0=Algos, otherwise AssetIndex - txid bytea, -- base32 of [32]byte hash, or NULL for inner transactions. - txn jsonb NOT NULL, -- json encoding of signed txn with apply data; inner txns exclude nested inner txns - extra jsonb NOT NULL, - PRIMARY KEY ( round, intra ) +CREATE TABLE public.txn ( + round INT8 NOT NULL, + intra INT8 NOT NULL, + typeenum INT2 NOT NULL, + asset INT8 NOT NULL, + txid BYTES NULL, + txn JSONB NOT NULL, + extra JSONB NOT NULL, + note3 BYTES NULL AS (substring(decode((txn->'txn':::STRING)->>'note':::STRING, 'base64':::STRING), 1:::INT8, 3:::INT8)) STORED, + CONSTRAINT txn_pkey PRIMARY KEY (round ASC, intra ASC), + INDEX ndly_txn_asset_extra (asset ASC, round ASC, intra ASC) STORING (txn, extra) WHERE asset > 0:::INT8, + INDEX ndly_txn_txid (txid ASC) STORING (asset, txn, extra), + INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES) ); --- For transaction lookup -CREATE INDEX IF NOT EXISTS txn_by_tixid ON txn ( txid ); - --- Optional, to make txn queries by asset fast: --- CREATE INDEX CONCURRENTLY IF NOT EXISTS txn_asset ON txn (asset, round, intra); - -CREATE TABLE IF NOT EXISTS txn_participation ( - addr bytea NOT NULL, - round bigint NOT NULL, - intra integer NOT NULL +CREATE TABLE public.account ( + addr BYTES NOT NULL, + microalgos INT8 NOT NULL, + rewardsbase INT8 NOT NULL, + rewards_total INT8 NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + keytype VARCHAR(8) NULL, + account_data JSONB NOT NULL, + CONSTRAINT account_pkey PRIMARY KEY (addr ASC) ); --- For query account transactions -CREATE UNIQUE INDEX IF NOT EXISTS txn_participation_i ON txn_participation ( addr, round DESC, intra DESC ); - --- expand data.basics.AccountData -CREATE TABLE IF NOT EXISTS account ( - addr bytea primary key, - microalgos bigint NOT NULL, -- okay because less than 2^54 Algos - rewardsbase bigint NOT NULL, - rewards_total bigint NOT NULL, - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the account is first used - closed_at bigint, -- round that the account was last closed - keytype varchar(8), -- "sig", "msig", "lsig", or NULL if unknown - account_data jsonb NOT NULL -- trimmed ledgercore.AccountData that excludes the fields above; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted +CREATE TABLE public.account_asset ( + addr BYTES NOT NULL, + assetid INT8 NOT NULL, + amount DECIMAL(20) NOT NULL, + frozen BOOL NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT account_asset_pkey PRIMARY KEY (addr ASC, assetid ASC), + INDEX account_asset_by_addr_partial (addr ASC) WHERE NOT deleted, + INDEX account_asset_asset (assetid ASC, addr ASC), + INDEX ndly_account_asset_holder (assetid ASC, amount DESC) WHERE amount > 0:::DECIMAL, + INDEX ndly_account_asset_optedin (assetid ASC, amount DESC) STORING (frozen, deleted, created_at, closed_at) WHERE NOT deleted ); --- data.basics.AccountData Assets[asset id] AssetHolding{} -CREATE TABLE IF NOT EXISTS account_asset ( - addr bytea NOT NULL, -- [32]byte - assetid bigint NOT NULL, - amount numeric(20) NOT NULL, -- need the full 18446744073709551615 - frozen boolean NOT NULL, - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was added to an account - closed_at bigint, -- round that the asset was last removed from the account - PRIMARY KEY (addr, assetid) +CREATE TABLE public.asset ( + id INT8 NOT NULL, + creator_addr BYTES NOT NULL, + params JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT asset_pkey PRIMARY KEY (id ASC), + INDEX ndly_asset_by_creator_addr_deleted (creator_addr ASC, deleted ASC) STORING (params, created_at, closed_at), + INVERTED INDEX ndly_asset_params_an ((params->>'an':::STRING) gin_trgm_ops), + INVERTED INDEX ndly_asset_params_un ((params->>'un':::STRING) gin_trgm_ops) ); --- For lookup up existing assets by account -CREATE INDEX IF NOT EXISTS account_asset_by_addr_partial ON account_asset(addr) WHERE NOT deleted; - --- Optional, to make queries of all asset balances fast /v2/assets//balances --- CREATE INDEX CONCURRENTLY IF NOT EXISTS account_asset_asset ON account_asset (assetid, addr ASC); - --- data.basics.AccountData AssetParams[index] AssetParams{} -CREATE TABLE IF NOT EXISTS asset ( - index bigint PRIMARY KEY, - creator_addr bytea NOT NULL, - params jsonb NOT NULL, -- data.basics.AssetParams; json string "null" iff asset is deleted - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was created - closed_at bigint -- round that the asset was closed; cannot be recreated because the index is unique +CREATE TABLE public.metastate ( + k STRING NOT NULL, + v JSONB NULL, + CONSTRAINT metastate_pkey PRIMARY KEY (k ASC) ); --- For account lookup -CREATE INDEX IF NOT EXISTS asset_by_creator_addr_deleted ON asset(creator_addr, deleted); - --- Includes indexer import state, migration state, special accounts (fee sink and --- rewards pool) and account totals. -CREATE TABLE IF NOT EXISTS metastate ( - k text primary key, - v jsonb +CREATE TABLE public.app ( + id INT8 NOT NULL, + creator BYTES NOT NULL, + params JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT app_pkey PRIMARY KEY (id ASC), + INDEX app_by_creator_deleted (creator ASC, deleted ASC) ); --- per app global state --- roughly go-algorand/data/basics/userBalance.go AppParams -CREATE TABLE IF NOT EXISTS app ( - index bigint PRIMARY KEY, - creator bytea NOT NULL, -- account address - params jsonb NOT NULL, -- json string "null" iff app is deleted - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was created - closed_at bigint -- round that the app was deleted; cannot be recreated because the index is unique +CREATE TABLE public.account_app ( + addr BYTES NOT NULL, + app INT8 NOT NULL, + localstate JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT account_app_pkey PRIMARY KEY (addr ASC, app ASC), + INDEX account_app_by_addr_partial (addr ASC) WHERE NOT deleted, + INDEX ndly_account_app_app (app ASC, addr ASC) ); --- For account lookup -CREATE INDEX IF NOT EXISTS app_by_creator_deleted ON app(creator, deleted); - --- per-account app local state -CREATE TABLE IF NOT EXISTS account_app ( - addr bytea, - app bigint, - localstate jsonb NOT NULL, -- json string "null" iff deleted from the account - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the app was added to an account - closed_at bigint, -- round that the account_app was last removed from the account - PRIMARY KEY (addr, app) +CREATE TABLE public.app_box ( + app INT8 NOT NULL, + name BYTES NOT NULL, + value BYTES NOT NULL, + CONSTRAINT app_box_pkey PRIMARY KEY (app ASC, name ASC) ); --- For looking up existing app local states by account -CREATE INDEX IF NOT EXISTS account_app_by_addr_partial ON account_app(addr) WHERE NOT deleted; - --- For looking up app box storage -CREATE TABLE IF NOT EXISTS app_box ( - app bigint NOT NULL, - name bytea NOT NULL, - value bytea NOT NULL, -- upon creation 'value' is 0x000...000 with length being the box'es size - PRIMARY KEY (app, name) -); +CREATE TABLE public.txn_participation ( + addr BYTES NOT NULL, + round INT8 NOT NULL, + intra INT8 NOT NULL, + CONSTRAINT txn_participation_pkey PRIMARY KEY (addr ASC, round DESC, intra DESC), + INDEX ndly_txn_participation_rnd (round ASC) +); \ No newline at end of file diff --git a/idb/postgres/internal/schema/setup_postgres_sql.go b/idb/postgres/internal/schema/setup_postgres_sql.go index 7636e9329..91d414b3a 100644 --- a/idb/postgres/internal/schema/setup_postgres_sql.go +++ b/idb/postgres/internal/schema/setup_postgres_sql.go @@ -2,131 +2,112 @@ package schema -const SetupPostgresSql = `-- This file is setup_postgres.sql which gets compiled into go source using a go:generate statement in postgres.go --- --- TODO? replace all 'addr bytea' with 'addr_id bigint' and a mapping table? makes addrs an 8 byte int that fits in a register instead of a 32 byte string - -CREATE TABLE IF NOT EXISTS block_header ( - round bigint PRIMARY KEY, - realtime timestamp without time zone NOT NULL, - rewardslevel bigint NOT NULL, - header jsonb NOT NULL +const SetupPostgresSql = ` +CREATE TABLE public.block_header ( + round INT8 NOT NULL, + realtime TIMESTAMP NOT NULL, + rewardslevel INT8 NOT NULL, + header JSONB NOT NULL, + CONSTRAINT block_header_pkey PRIMARY KEY (round ASC), + INDEX block_header_time (realtime ASC) ); --- For looking round by timestamp. We could replace this with a round-to-timestamp algorithm, it should be extremely --- efficient since there is such a high correlation between round and time. -CREATE INDEX IF NOT EXISTS block_header_time ON block_header (realtime); - -CREATE TABLE IF NOT EXISTS txn ( - round bigint NOT NULL, - intra integer NOT NULL, - typeenum smallint NOT NULL, - asset bigint NOT NULL, -- 0=Algos, otherwise AssetIndex - txid bytea, -- base32 of [32]byte hash, or NULL for inner transactions. - txn jsonb NOT NULL, -- json encoding of signed txn with apply data; inner txns exclude nested inner txns - extra jsonb NOT NULL, - PRIMARY KEY ( round, intra ) +CREATE TABLE public.txn ( + round INT8 NOT NULL, + intra INT8 NOT NULL, + typeenum INT2 NOT NULL, + asset INT8 NOT NULL, + txid BYTES NULL, + txn JSONB NOT NULL, + extra JSONB NOT NULL, + note3 BYTES NULL AS (substring(decode((txn->'txn':::STRING)->>'note':::STRING, 'base64':::STRING), 1:::INT8, 3:::INT8)) STORED, + CONSTRAINT txn_pkey PRIMARY KEY (round ASC, intra ASC), + INDEX ndly_txn_asset_extra (asset ASC, round ASC, intra ASC) STORING (txn, extra) WHERE asset > 0:::INT8, + INDEX ndly_txn_txid (txid ASC) STORING (asset, txn, extra), + INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES) ); --- For transaction lookup -CREATE INDEX IF NOT EXISTS txn_by_tixid ON txn ( txid ); - --- Optional, to make txn queries by asset fast: --- CREATE INDEX CONCURRENTLY IF NOT EXISTS txn_asset ON txn (asset, round, intra); - -CREATE TABLE IF NOT EXISTS txn_participation ( - addr bytea NOT NULL, - round bigint NOT NULL, - intra integer NOT NULL +CREATE TABLE public.account ( + addr BYTES NOT NULL, + microalgos INT8 NOT NULL, + rewardsbase INT8 NOT NULL, + rewards_total INT8 NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + keytype VARCHAR(8) NULL, + account_data JSONB NOT NULL, + CONSTRAINT account_pkey PRIMARY KEY (addr ASC) ); --- For query account transactions -CREATE UNIQUE INDEX IF NOT EXISTS txn_participation_i ON txn_participation ( addr, round DESC, intra DESC ); - --- expand data.basics.AccountData -CREATE TABLE IF NOT EXISTS account ( - addr bytea primary key, - microalgos bigint NOT NULL, -- okay because less than 2^54 Algos - rewardsbase bigint NOT NULL, - rewards_total bigint NOT NULL, - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the account is first used - closed_at bigint, -- round that the account was last closed - keytype varchar(8), -- "sig", "msig", "lsig", or NULL if unknown - account_data jsonb NOT NULL -- trimmed ledgercore.AccountData that excludes the fields above; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted +CREATE TABLE public.account_asset ( + addr BYTES NOT NULL, + assetid INT8 NOT NULL, + amount DECIMAL(20) NOT NULL, + frozen BOOL NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT account_asset_pkey PRIMARY KEY (addr ASC, assetid ASC), + INDEX account_asset_by_addr_partial (addr ASC) WHERE NOT deleted, + INDEX account_asset_asset (assetid ASC, addr ASC), + INDEX ndly_account_asset_holder (assetid ASC, amount DESC) WHERE amount > 0:::DECIMAL, + INDEX ndly_account_asset_optedin (assetid ASC, amount DESC) STORING (frozen, deleted, created_at, closed_at) WHERE NOT deleted ); --- data.basics.AccountData Assets[asset id] AssetHolding{} -CREATE TABLE IF NOT EXISTS account_asset ( - addr bytea NOT NULL, -- [32]byte - assetid bigint NOT NULL, - amount numeric(20) NOT NULL, -- need the full 18446744073709551615 - frozen boolean NOT NULL, - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was added to an account - closed_at bigint, -- round that the asset was last removed from the account - PRIMARY KEY (addr, assetid) +CREATE TABLE public.asset ( + id INT8 NOT NULL, + creator_addr BYTES NOT NULL, + params JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT asset_pkey PRIMARY KEY (id ASC), + INDEX ndly_asset_by_creator_addr_deleted (creator_addr ASC, deleted ASC) STORING (params, created_at, closed_at), + INVERTED INDEX ndly_asset_params_an ((params->>'an':::STRING) gin_trgm_ops), + INVERTED INDEX ndly_asset_params_un ((params->>'un':::STRING) gin_trgm_ops) ); --- For lookup up existing assets by account -CREATE INDEX IF NOT EXISTS account_asset_by_addr_partial ON account_asset(addr) WHERE NOT deleted; - --- Optional, to make queries of all asset balances fast /v2/assets//balances --- CREATE INDEX CONCURRENTLY IF NOT EXISTS account_asset_asset ON account_asset (assetid, addr ASC); - --- data.basics.AccountData AssetParams[index] AssetParams{} -CREATE TABLE IF NOT EXISTS asset ( - index bigint PRIMARY KEY, - creator_addr bytea NOT NULL, - params jsonb NOT NULL, -- data.basics.AssetParams; json string "null" iff asset is deleted - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was created - closed_at bigint -- round that the asset was closed; cannot be recreated because the index is unique +CREATE TABLE public.metastate ( + k STRING NOT NULL, + v JSONB NULL, + CONSTRAINT metastate_pkey PRIMARY KEY (k ASC) ); --- For account lookup -CREATE INDEX IF NOT EXISTS asset_by_creator_addr_deleted ON asset(creator_addr, deleted); - --- Includes indexer import state, migration state, special accounts (fee sink and --- rewards pool) and account totals. -CREATE TABLE IF NOT EXISTS metastate ( - k text primary key, - v jsonb +CREATE TABLE public.app ( + id INT8 NOT NULL, + creator BYTES NOT NULL, + params JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT app_pkey PRIMARY KEY (id ASC), + INDEX app_by_creator_deleted (creator ASC, deleted ASC) ); --- per app global state --- roughly go-algorand/data/basics/userBalance.go AppParams -CREATE TABLE IF NOT EXISTS app ( - index bigint PRIMARY KEY, - creator bytea NOT NULL, -- account address - params jsonb NOT NULL, -- json string "null" iff app is deleted - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the asset was created - closed_at bigint -- round that the app was deleted; cannot be recreated because the index is unique +CREATE TABLE public.account_app ( + addr BYTES NOT NULL, + app INT8 NOT NULL, + localstate JSONB NOT NULL, + deleted BOOL NOT NULL, + created_at INT8 NOT NULL, + closed_at INT8 NULL, + CONSTRAINT account_app_pkey PRIMARY KEY (addr ASC, app ASC), + INDEX account_app_by_addr_partial (addr ASC) WHERE NOT deleted, + INDEX ndly_account_app_app (app ASC, addr ASC) ); --- For account lookup -CREATE INDEX IF NOT EXISTS app_by_creator_deleted ON app(creator, deleted); - --- per-account app local state -CREATE TABLE IF NOT EXISTS account_app ( - addr bytea, - app bigint, - localstate jsonb NOT NULL, -- json string "null" iff deleted from the account - deleted bool NOT NULL, -- whether or not it is currently deleted - created_at bigint NOT NULL, -- round that the app was added to an account - closed_at bigint, -- round that the account_app was last removed from the account - PRIMARY KEY (addr, app) +CREATE TABLE public.app_box ( + app INT8 NOT NULL, + name BYTES NOT NULL, + value BYTES NOT NULL, + CONSTRAINT app_box_pkey PRIMARY KEY (app ASC, name ASC) ); --- For looking up existing app local states by account -CREATE INDEX IF NOT EXISTS account_app_by_addr_partial ON account_app(addr) WHERE NOT deleted; - --- For looking up app box storage -CREATE TABLE IF NOT EXISTS app_box ( - app bigint NOT NULL, - name bytea NOT NULL, - value bytea NOT NULL, -- upon creation 'value' is 0x000...000 with length being the box'es size - PRIMARY KEY (app, name) -); -` +CREATE TABLE public.txn_participation ( + addr BYTES NOT NULL, + round INT8 NOT NULL, + intra INT8 NOT NULL, + CONSTRAINT txn_participation_pkey PRIMARY KEY (addr ASC, round DESC, intra DESC), + INDEX ndly_txn_participation_rnd (round ASC) +);` From 17a3907b71b1049f99ff256ae786612a5c57a2e8 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Sun, 8 Sep 2024 21:25:50 -0300 Subject: [PATCH 4/9] Add `group-id` filter to `GET /v2/transactions` --- api/converter_utils.go | 17 + api/error_messages.go | 1 + api/generated/common/routes.go | 360 ++++----- api/generated/common/types.go | 3 + api/generated/v2/routes.go | 1390 +------------------------------- api/generated/v2/types.go | 6 + api/indexer.oas2.json | 23 +- api/indexer.oas3.yml | 16 + idb/idb.go | 1 + idb/postgres/postgres.go | 6 + 10 files changed, 252 insertions(+), 1571 deletions(-) diff --git a/api/converter_utils.go b/api/converter_utils.go index 8b4081acd..f3b2e4103 100644 --- a/api/converter_utils.go +++ b/api/converter_utils.go @@ -110,6 +110,20 @@ func decodeBase64Byte(str *string, field string, errorArr []string) ([]byte, []s return nil, errorArr } +func decodeGroupID(str *string, field string, errorArr []string) ([]byte, []string) { + if str != nil { + data, err := base64.StdEncoding.DecodeString(*str) + if err != nil { + return nil, append(errorArr, fmt.Sprintf("%s: '%s'", errUnableToParseBase64, field)) + } + if len(data) != len(sdk.Digest{}) { + return nil, append(errorArr, fmt.Sprintf("%s: '%s'", errBadGroupIdLen, field)) + } + return data, errorArr + } + return nil, errorArr +} + // decodeSigType validates the input string and dereferences it if present, or appends an error to errorArr func decodeSigType(str *string, errorArr []string) (idb.SigType, []string) { if str != nil { @@ -714,6 +728,9 @@ func (si *ServerImplementation) transactionParamsToTransactionFilter(params gene // Byte array filter.NotePrefix, errorArr = decodeBase64Byte(params.NotePrefix, "note-prefix", errorArr) + // Group ID + filter.GroupID, errorArr = decodeGroupID(params.GroupId, "group-id", errorArr) + // Time if params.AfterTime != nil { filter.AfterTime = *params.AfterTime diff --git a/api/error_messages.go b/api/error_messages.go index a1bfbfbc2..70dbebb69 100644 --- a/api/error_messages.go +++ b/api/error_messages.go @@ -14,6 +14,7 @@ const ( errUnableToParseAddress = "unable to parse address" errInvalidCreatorAddress = "found an invalid creator address" errUnableToParseBase64 = "unable to parse base64 data" + errBadGroupIdLen = "bad length for group ID" errUnableToParseDigest = "unable to parse base32 digest data" errUnableToParseNext = "unable to parse next token" errUnableToDecodeTransaction = "unable to decode transaction bytes" diff --git a/api/generated/common/routes.go b/api/generated/common/routes.go index bf1f44d7f..dc9baf97c 100644 --- a/api/generated/common/routes.go +++ b/api/generated/common/routes.go @@ -73,188 +73,188 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL var swaggerSpec = []string{ "H4sIAAAAAAAC/+x9f5PbNrLgV0HpXlXsnDjjOJvU26naeuXYScW1dtZlT7J3z5O7hciWhB0KYABwJCXn", - "736FboAESVCiZsZjb9X+ZY+IHw10o9Hon3/McrWplARpzezij1nFNd+ABY1/8TxXtbSZKNxfBZhci8oK", + "736FboAESZCSZsZjb9X+ZY+IHw10o9Hon3/McrWplARpzezij1nFNd+ABY1/8TxXtbSZKNxfBZhci8oK", "JWcX4RszVgu5ms1nwv1acbuezWeSb6Bt4/rPZxp+q4WGYnZhdQ3zmcnXsOFuYLuvXGs/0ocP8xkvCg3G", "DGf9myz3TMi8rAtgVnNpeO4+GbYVds3sWhjmOzMhmZLA1JLZdacxWwooC3MWgP6tBr2PoPaTj4M4n+0y", - "Xq6U5rLIlkpvuJ1dzJ75fh+OfvYzZFqVMFzjc7VZCAlhRdAsqEEOs4oVsMRGa26Zg86tMzS0ihngOl+z", - "pdJHlklAxGsFWW9mF+9nBmQBGjGXg7jB/y41wO+QWa5XYGe/zlO4W1rQmRWbxNJeesxpMHVpDcO2uMaV", - "uAHJXK8z9ro2li2Accne/vCcff31139mtI0WCk9wo6tqZ4/X1GCh4BbC5ylIffvDc5z/nV/g1Fa8qkqR", - "c7fu5PF51n5nL1+MLaY7SIIghbSwAk0bbwykz+oz9+XANKHjsQlqu84c2Ywj1p94w3Ill2JVaygcNdYG", - "6GyaCmQh5Ipdw34Uhc00H+8ELmCpNEykUmp8r2Qaz/9J6XShdhnBNCAatlA75r45TrpSvMy4XuEK2Rcg", - "c+XweHHDyxq+OGM/KM2EtGbucQ2+oZD24qunX//JN9F8yxZ7C4N2i2//dPHsL3/xzSotpOWLEvw2Dpob", - "qy/WUJbKd/DMbDiu+3Dxv/73f5+dnX0xhgz857QLKq+1Bpnvs5UGjhxnzeVwD996CjJrVZcFW/MbJBe+", - "wavT92WuLx0P3M0z9lrkWj0rV8ow7gmvgCWvS8vCxKyWpWP1bjR/fJkwrNLqRhRQzB3OtmuRr1nO/YZg", - "O7YVZemotjZQjG1IenVHuEPTycF1q/3ABX2+m9Gu68hOwA75x3D53+88lywK4X7iJRMWNoaZOl8zbjxU", - "a1UWRPTRBcBKlfOSFdxyZqxyjHWptJd4iOvOff9WiGM5IrBgi32/pSw6ox/v4/YHdlWp3MqWvDSQ3q+w", - "+niTcJWxbMHLcuZvLCdo+Smz5gdeVSbDFWfGcgtxm6pyLaSSkBBAmh+41nzv/jZ276QsZK2zFjtZXioD", - "mVVHBLAgU+GGRSJTvGMniWPscg0MJ3cfSBRFypaOS5flnlmPAEcQLAhfcyaWbK9qtsWjU4pr7O9X42h6", - "wxzyEWUdSdFxszHiHmxGgrQXSpXAJZL2GngBOlOy3A/37Uf8yNxHtiz56oz9fQ3+MLu730FH4MyZBltr", - "6aisVPk1KxQYJpV1coPlQvZFdjMCfwzPEdD9qyFzpDcuv5ThSFJzJ6rg3hSNaDNnBZSA+GnPD/5qrFZ7", - "xJuj4jlTlaNXVdvhuZaFH5Y+94850vzoAyVeyZFFl2Ij7HC5r/lObOoNk/Vm4TC2bGQdqzxqkE41sBzJ", - "bdFhWhVfgWHgRCFBryucxyHZ4VADz9fjDJVgOsJDN3yXaVXLYsIjwjKlYyHNVJCLpYCCNaOMwdJOcwwe", - "IU+Dp33aROCEQUbBaWY5Ao6EXQKtjrO4L4igCKtn7Gd/7eFXq65BNrcj8XlglYYboWrTdBqTltzUh6Uj", - "qSxklYal2A2BfOe3wzE3auPv5o2Xpz0LgIJ5PuCGI0Y5ClM04amPhgU38O2fxiTm9quGa9gn74s+AdBy", - "Gi3F2n2hvodX0cxw5FBPpEMSD2L6O0h7k+gOG2XENhLinfvqmUpaI9TpP0HkjucmfUR2J90QjRFu5rGt", - "6M308Z6hRqwyGnFwSsTq0okRS1GiiPFPdzgCZmvj7qUuboPQYcRKcltruLiSX7q/WMbeWS4Lrgv3y4Z+", - "el2XVrwTK/dTST+9UiuRvxOrsU0JsCZ1RdhtQ/+48dK6IbtrlpuaInxOzVBx1/Aa9hrcHDxf4j+7JRIS", - "X+rfSWzEK9FWyzEAUvqRV0pd11W8oXlHX7jYs5cvxogFhzzED5F3mEpJA0i1z0iQeOt/cz85lgcSOXok", - "C5z/0yh8RLVjV1pVoK2AWD/r/vsfGpazi9n/OG/1uefUzZz7CWfNI82OXWV0gLn1LIxYl2dqJAxsqtrS", - "1Z7iDs1xft/A1p+zRYta/BNySxvUBeMRbCq7f+wA9rCb+9st03mQTNy3/qPiI+4jXe4ZXtLDkX82/uFX", - "8ZWQuPA52zoxe8OvHVfgUtk1aOZwAcaGa57YH938jWLZywr+rXA2S52YBE7NnZHaYu2VE3ffobh7Hyju", - "PRtPwHUKpH9jvsH8YGPvkwRW94T7gxr3q6v3vKpEsbu6+rXz4hKygF0aHx8V2aVaZQW3/HY0unrhuiYI", - "9HOmoa41474I6H6J5wQsPOyNel/bdc+H7VY89t+cNXEq7s5UjQH7HS+5zO/lOl34oSZj+LWQAoH4kVRd", - "/0ZzQHOzlfeBYr+793KQSeM++Qj/G7mpM9zYMe6M2vtC6SREPvCLEKe8j036VIT/b4q/X4r/rlT59a1w", - "eQhVOOqxmdXu/udVu9Ss36kdE5K0f17y+U7t4HN98iwcbJOPxXdq98JPqfS/9muEFj6Fgr/zfjEGjbwy", - "3lm35O+1VvoesBvehj145rMNGMNXkLa9xGsMDacsKgCMCAG3BNRQ/wi8tOvna/gIBzUa+8hxvWyVsfew", - "sR+VZUd642Prj1Z15LHXHfZELhtNYz733ft82EVny6czxA5O++xwOo7NaUj+EOwPsYEh4dLnfbaj68hh", - "inu3RjIPXskr+QKWQqK1/+JKOj50vuBG5Oa8NqD9A/NspdgF80O+4JZfydm8f0GN2erQBctDU9WLUuTs", - "GvYpLJBvWGIEZXkZOTBEbmLebNxaIIZ0RqNmjhxUbTPvlZpp2HJdJOA1jdEaRyZ/tUOzzpkfm2zr3uvV", - "j5+m/YHP09Dn/qA7mJBdfy2HyJ+U9RZovmVESKw2YNg/Nrx6L6T9lWVX9ZMnXwN7VlWt5vsfrXOZAxRt", - "X/eqRsfFIg4z2FnNM/QpSROKqTd405Ylw7ZdxzWtVppvvE9K3yXuwE7T5NNuqmhZuKJ31OvDPHpG9FCF", - "v7M1lENHulMRE725b42XI+/2A67dl1EEAl9xIU3g7UaspKNq7825AJa7uxyKM/ZyyZA3zTsBDD4Uw/O9", - "hgEIQw6Y7NKtC10kWM4lOmZWBbrCCcm43PeNsgasDZbwt3AN+8vIw+JES713x+JHLraidsM1l1uLVbbl", - "hm0UWulzkLbcew+vBAmmgamFtORq0nF1HAASOR66UxHpD8dcNyNnNl5VbFWqhecdDS1eNMQY+oyziTcO", - "AHMPLCL5nu66gh5bPR2zMZfV01fnxrvTITu4plsT11Jog36CwD2r5/FhuAWNeSfGISh/XwNKUUqjM1+X", - "jkw4vCnybnyU0NkSpBU3kEEpVmKRinPKeefGDJ6u3iO0GcEwsWTCGuZVqA4IIZnmcgVOenEShzK8pKiM", - "JDQlNzZbA9d2AXzEbw4R0zqKd5bt+rOtY1lKlkLC3G0O7BwdC7cTGiRsoXCrEdq3Ye4Or0euegSIAE+h", - "YBI8oTvuIe5Zeq6NkJnfuoQjaJBfmt0NAmpwC4yPEsJF3zeAAQxq6/DioFDe937gWV67J2gatIprK3JR", - "TbO7ESBvOn3cIMdkt6S0ppZ9oWwgPyVBpsaZW/NwptqQ17ZbV7jswuj07kGozxi6qvlNWpToyN1EThG+", - "uUYP87BUiiQaA8eMicdh8u7a40O35iYcPIyTCPfEJIl1hJm15Ov4aES/8btDuHlLuOFjOz3uG4e+4X13", - "NxQhhnEOwamUIkGDT1xwhAveb+5fx+/qsnTcppbXUm3dc+YU/7b5jI78EOAbhWIKfQ6E4UH8wkSocXD8", - "bblE/pExIQt3iPDRwW0IW1G5oOiAlic7Xr5yP565ARx1uQEmj5AiWz8kSthKlTQw+0nF50+uTgFSgsB7", - "hYex8YKJ/ob0KxzFdJTYyZ9eyDTF5eGUu3dCRypCwDDWaAEgyS2fCTlnjpXd8NKxMqtING0GST+1HnVe", - "SV5wN4/HnmBpDRGtCCWXk9ZEss5tVhOL/wHo9NvkAMQLtcswdm8IK4bgVVXWMDElyz1FuvTf6TiCW4/K", - "kUKCl/I17CnIBsO+8JSgRtbzjwWUykn6akBhLaKOAH9XwO8RmsMCfoqaDZIeSd4t2R0I1To69Yh8PUZ2", - "j5CG7gBAX//eOFd7Dc9RpUxXlBle/O1tOG+d2Ykjp9nI2FEcEnyXipJYHNnfoRqv8Wl905d+ksq6TitG", - "TRZeDxW9hVK3n2NHuZIGpKkxGtKqXJVnAy2dgRLwGZF1BLLsGhJBXu9C40hvxx6JpXufP45eBxpWwljo", - "xCk28QdteMUeY/sqbi1oN/z/efRfF++fZf/Ns9+fZH/+n+e//vGnD4+/HPz49MNf/vL/uj99/eEvj//r", - "P2Yj1zI4cVst02t6q1Rz8WFjho07S3twqG+UhQzffdkNL1PmvR/wUZiUtDqIZBRMK0Z07jjRNeyzQpR1", - "mhZ/arigqRfIqYVkwB0n5DZfozTdmdG1OTAbvn9GVvWK39uiJpCzdqjvDvwvQtc9fnroECeIKYX2IXJG", - "9/EAW0PJ6AWUZLwcz3pBB61wDc8OGQ4GB6MIYx96LUZQjN88NFJyLV1/0PFVoCUd5RZho7hbM1jRVB3Q", - "tgmZjUXQLW+UXB9d1xOvLtb3+FHSKhb/8Q7LGw4/dXnJ9ETTvB0QYaeoLEkAGtAUnhU/2BF6iuwiw8vV", - "PSOMf3DQAYmES4pHl30hs0dnTVjxNFwEWcFHOau6uQkPy7L3R3OQeGzR2lPkx5ZabfCwDWXNWAE5opfo", - "UF17tfRm9WmThvTi+CU+UI7agYGXf4X9L64tYtX1DhLm1FPSqmnCKy+8OO6EmrvZvFKU70c8SvkUtDBG", - "9phgh2wTHQv1iSegVCuTivFbtSGxMRUswD2KYQd5bVu1Z0+53uj/H1YG7BsS0uGLkc8BJXk6LCng/vix", - "jmDsTcMePybCeFVpdcPLzNtyk9wcWwRr7wPLWukDdfn9s1dvPMRoQASus+atkV4INmrfGJ/tWpyooY4Y", - "g1ERFRQA/SvdG3OF6RiAt5hSovd0dcKTpyLamNaIHx1TbxBeBlH7RPOudzKgJR5yNmgVPuRr0PUv4Ddc", - "lEFlH2BMXxW0pNaV4+TbIh7gzn4KkV9Jdq/8f3B40yfhCKOJZziQMWJDeUsMUz4zRIss9xhFowCS5Ybv", - "HbWQWnbIcWS9Qc1OZkqRMot11ZUMW428Z91Q7mo9NIj7biboxHpgRYMnty/4+Y/t1kJ5Z7dait9qYKIA", - "ad0njWeudwzdqQsJtG79eklYsCnR1gO+X3DCU14uPm/PnRbXjHKb94t7nySsiYQ1v54Gd3d5x7Qq3KEc", - "h0AcfsTETkQDcF80qslARY2FgcuOGfkE78J4xoHYMOIZGJ07Kbyd4xZYOZ5OMzyUfF6nNH846R0Up4m6", - "0+vHZEutfk950W6H00YTUq/0oJNfL71zMvKKEb10d7dAUZNg664gNa/eOwPVvx0b20abY7VFzughG5O7", - "YxtM1yV1hJHjecMwEK6vrn6lh2Ww83JJB+w55mrtPHnSxzR2UD6n8dtj6mEe6iP4dsHz68RiWq/AjiXa", - "KhY6NSnTutg5Y5GDYdPWZx+rQG+E7bL79kV1W8mWpp0s07YiLFJTLLz63IulUYlharnl0oYccp6B+d4G", - "yKTjem2VNhazWSZXWUAuNrwcMe+1DLIQK0FJ32oDUcoy359VSkhLRFMIU5V8T+6W7Y68XLIn84h5eSQU", - "4kYYsSgBW3xFLRbcoCzSaphCF7cqkHZtsPnTCc3XtSw0FHbts+kZxZpHBypoGs+PBdgtgGRPsN1Xf2aP", - "0MvFiBt47DbPy5Szi6/+jBZG+uNJmpdj3tFR3hpYeppq0aeHurpL0Q+W5rWUZ/ukM0NdppwYbOkZ/vET", - "s+GSr1LZvg7AQn1au35vH2RBKTNRZGLCpucFyx3XydbcrFPpiXO12Qi78f4ORm0ctbQJsWiuMArZ9Ild", - "N+CEj+iBXLG0cu1hNT7pXMw/8Q10N3HOuGGmdqC2SivP3M6YTwVXUC7OVpuIW0IpnckjjXS+yyjhcm2X", - "2X+yfM01zx0rOxuDMlt8+6chpN9hvjyG+aGhoLmmA/7g263BgL6ZdtCCmOT7sEdSyWzj2EPx2HPq7pkb", - "dWdKs+W+w8nhIafKSG6U7DBV8YjL3om+5IEB70hxzTJOIruTV/bgBFjrBDX8/PaVlwc2SkNXt7oIMUUd", - "yUKD1QJuMPQijRs35h1RoMtJm38X6D+tDT0Ih5EAFU5sSlSnQPPhdnj/9WbZY49epa6vASohV+fkv43C", - "NI3aF6MXStYjGstKOdlJ8JJhI1bxvdvlRgQ94Bu+BDBZrsoS8uQbtRd95Zqzigs6NnGGzeD4eGCuFUgw", - "woxc51dX71dr90Jxn91NHGlZKCCAfO7Mwx/RAPhIhP0KpIP75YtjUA8G7rpVUKjTUR1Oxx/sZ9/HDebT", - "92Y47/guu3YO3jch3S/B6do//Nb6GAY9Qtj+a8O/+9Q1VfkfBsroaIyFo9qalyG2E6l7CdoXMOmAgzoY", - "LDEBwIyQ10d984+mq3jr24471V9dvdeycJh77sPnyEeqa8cmZG452iVAFi30+ZqLEZ9UA5Ce0H1wM75T", - "2gpy2gH4xA58VvP8OqmAvHRfTOPER572kTufmRzIhdaIN67PZZgtZYwVGzCWb6rk3lnjdo7uArxX3PY1", - "XRzDNJArWRhHQTkwqJRZH8soYNJT7SROVgpDsk7MmXOlKfssyq5W9aK9p27Jwbj2LoyZVsqOAerg7CQk", - "UMoyXtu1u8JCHAFgrYD+Sij6Dd+tMgp6Yq+dlBHy9vKy3M+ZsF/QONp7dnK2AX1dArMagG3XygArgd9A", - "W1QER/vCsMudKAyWDClhJ3K10rxai5wpXYCmajOuOb6lqZOf78kZ81G9Pg7icidxeU1xg3idtMwQvdJY", - "tOIVz0mE6/+MtR4MlDdgztjlVhEQps1tYJz02+mxqC3FDBZiuQTkHrgcfIpjv/ZDBBOWR8FQg2ZYv6aH", - "5wEDCsvMmj/95tsxQnv6zbcpWnv347On33zrJGEuGa93ohRc7+NmrtWcLWpRWp9om7MbyK3SscZBSGOB", - "FwPaIm2UnwVlmWUtc++G1nSJi9i8+/HZN189/b9Pv/nWq6+iWUIUtA+wA3kjtJLuU1AYNhTip2xmg50w", - "9hNIS3YnM3wvp251h5oc0bKTz6kR84EXXXNuj4VtSD8VDn4JxQr0vL2IHV9tc464x53SkQS8BAoRc/ei", - "kFaros6BMl286/CNCCwxAKkpnxC52+BZD1WEWjiDJrWRWRh7iS/gJ/Qgk6q7QjxjcAOaYnragR7R5RDB", - "ZSzX6KeEbkt+qVA8Tl/tdbXSvIBpXgh4Wf1MPZrEDWGEG3XaAL+49v0HVucN0JGs0wJsFMjhZJT4zk3d", - "OQe4xOj77e1YBOUPVJlHQ0mhblgZBdvOB6+zJUDmBMEkxbtXEybgynOoHKXHlSgB3F1DJx3PMlbIC0Jb", - "EwRNQXhpDRbClOW8zOuSnhIHRMhtzku0BLWEXcLSKkd7caWt1hQg3FwL9BCnkiI0n3Z3WNQD00bdgN77", - "FqR5CRU83LnRPdedoaiclXADZRJw4Bplhx/Vlm243De4cFO0YMyjyLgGchKC0UOEsP2zVwpF4NM58wR5", - "GEiHipHNLWI8V6CFKkTOhPwn+IMePx2QYqgUkJJWyBqLP2lo4aarnmGIbj8Md0gBOulS7ODiFhxgbRSH", - "hG0H20X0UOgGQxjLr4HADsHEXrqZilMNRhR1GrKl5nkXstOI0R/et9zCuW5Qa+6JLnvMqznkhw5dn5Z7", - "ZNPD1nCXRvlUhy9PYVa8ifhinocnnMV9BqrQckRjoKzCSzvK3dKMfQPadN2QIzMB7I6M7Vp0xqe8XCG1", - "wemzZMEfzYzOtyd23NJckJ8p8B77+7QKqR0cSVrWAGC2wubrLBU44gGgFg6Gt/0n/HBKki7wFMJyCbmd", - "AgNG7VBFrFEo6LOD4gXwAiPG26grirfqg/LoJ8Xc0CYSeaQR+JBoJR4c5fEJCc0bCjlG/L+oibTvA+7R", - "E2LCMQgyjsd9cst8G088L5uod872YHBXGu/y6IxgZpK0iTdMWkDJ94emxAbdSRuZNxi36c7BBB7uQiFv", - "9tEg5DC1P2eHJndN+gtujufwVMSldgaYVAknt5BLswmh8lkJEz6bSRuWI2a+QTIO5WrnbNExSDy8UfF+", - "0mKk4xpD8MlgG/BL2Af8o78Rn9i6Esrs+nuSVvJrmlCipLJJkima71FINMUZ4PpD8j3uq8hOpKaeJStQ", - "1Gewb6l9+v6GlyOBlm+h0mBQT8DZ5ffPXnmnmLFwyzwd6Xh19Z5bR1PYj40mm/own41khri6er9Ajkl5", - "HxpsDK2LSR9qx4iE6+4+D3rfziVvLIlqtKHBF38I0F9DABiruPCOXm2s6XBnfdDxMLp7ShBZi+D+InxU", - "7+gR+pGb9Q88t0rvhxlc3dN6JLXO1dV7h+9Ttvirb9Ps3oGQnuQyyt/TVZE1/n/oexfkIbUc5PFhmMhn", - "zb3mLPzpXvpR0p7m+2w+G+gBWlzEeYgTfkZr/Ey5DVmo5DbE9Gi65mKRNWEjqYqO85lPtxznmD0aCiZM", - "thErjSJPetTxNNHRFZW4YUjUTpRF9mLNuCzeI9LOwnsQt+BFN4KfOUXQL2UBO9CtZeZ1u7qepZzUR1gY", - "2GStMjXNm4jYH1Y+oDh8N4WxUBzQ1ixPPIrk8VM6MW3S+OXtxpcZisky24JYrdMb++ZWQzsx+jjSbh4e", - "aSkG9xq1/s/cgUSKHGG0y5YNH0yGHnFs9A2wI/Z7u6blfy4hqRrcG6YaAdcWJxLCf45sdr+yUIJRG7Gp", - "SnL+9KxkkPvqpEQTbYDJx49Xuu+gj48evgG39ki8/6iN28JyPCXV4ViNv8nnalOVMC48V1yS+LwU0r/b", - "t2tu42LqwQak8rzWrRG3H43xCy8FVfk1mMVQKlVh2sLKCun+gwkcVG3p/8C1+w85FXX/R1QVyUluqBni", - "BZNfhYFCJOdsPqPOs0DZSSkq6Zg02JRuOquAT3TCRluaBCgwIKHNJn3Oc0v2T++sKcFulb5OPGMWBvVJ", - "Hb+quOzrkJtybeuK0xOFNx4UPoVrkxWuAc1DZmpD3jUd/4mjvBJ2laO10wEs9OZmIoTN5il5A9rbPpTP", - "KUlWDkpTO0jYxDx4p6wpxapvmQBokhvK8IWW2OZWSCTVYNq3CdVaOn4nR75CQ5fNXO8rq86xDTY5N1bX", - "uTXktdnOOaBKt9HkvHS8fl5fpHCSgDKC7JlWZRpugI+p6dFVC36rwSEZTXWuMWsGSCF2KtPu7zGNnd5a", - "BCR2haGgKXKwK/chWSZ3e77h1Xua5VeWsbcEcVNKAT3yNmZVne65RUOlQDe8tNnoK8fLl+wdL20sRjiA", - "vJ9H4yEznriWJNjk6PmneHI4mG5Pgm7BUBwS97e3EPdHeQfO21wUJIF1j9QNaIqFnkwOv4QeH+azB13H", - "2+bEDrlCtL5pq4g3JWINaRVL+BqOU5sqmcuCRfMbhmcj4SuIRxek1fvbpBkSq8yU6oTlvROrd67DkS0N", - "zQZ7Wqot6MzNewDFZTA1UrwNteykkm5qudB45CkBBXOLMbfbCBr4pJ3wXY7vRTt2zymFl7mSWWf2h+U6", - "xC8zpK6syXJwZPf4prt7VXhbn8q1kEnshVylMz86Rn8N+89Dl5DwOB7gE02848ocfGj81Dg0REamrTci", - "k5GwK+gcqSLhnmsoafpyOQfOle2eq9a/aCNyrTg6Y7Qpp2EgwfrHHvoyNrtxyMEkrVymxNzU+XJfQeOU", - "Oyy1s+FVeG/hO9wJwWcfU2nF3jbuyEOP0lxJywUW1EkK9+SMC2WFjKrVjZ99VuT7S3Qz93xNDu9PvkEC", - "igxXsf+2+/9wy6wGeHgP12vYZ6VYghUjBuly6VbyV9iz0Ozs3mSKsRxJHYMfah5Kiglo8z4xpenLCr/E", - "6aUY8VEMkjbhL8MKsKA3jhTXass2db5G2Z2vICRYQoMNepb3JuqMHjJSdNOD+fhAU/GcBqKw/5LrFWjm", - "I/GbuiTBALThAs9J6w3cj89FRzGeMsYdS/v0mlIBRLwLTadRDqhEdqkAxjXsz8kyiL/fgpGMp5IaAQzz", - "Sn1EkO6UnirOaXaEXq87RlUq9tVJ/taAf4/GVQefVyGcaFwdZmubujxcBx6H2sBwndOjceK9TTxx27VN", - "9QwYbu6IQf+YHX+kZIs39yIfx74M4WP/+OofTMMSNOqtvvwSh//yy7n3V/jH0+5nR21ffpl2akqenPvz", - "G2gqAbgx/HRJ6ugWgO3ZUOmSNxROS45r7kJTEl02y7IX8iQLhskGUDzhGAECpaog2RqLlcU3KCaA07Cq", - "S06hPkJK0J1OUzL90PPf7qRXdeGflzuZahuLk9g62o5UgdCoCvPtKuf2yslRnqUcMxrddsQ2J1I7ImVX", - "ucuIP1BKl2bEEGF6lzEv/RhHSjheXb03K4lquaCMEyFLAArAhOEuNTWZA0KZx5CpqAlng99qXvpwPYnB", - "cZeYtie/BkkVHB2X89V3GUhTa68SdLDieA4UP4yKL3PTNrltLcfxgmBXV+91Ttpf79Huk0Fg5inq6sSM", - "wiFHHS6q4tq7J+ZYMjon2XI3l28Y4ovRV/TY0wvJWG/Gbfi9bNFxZAlmXAz9R4Zv65e0pdDTuQjbpJK9", - "m5ny3z96+eIxE/1i6HHWx+ihdXzZcQmVaRBRhpEBLP3ck6dAsQQYC+fpBRayJYyogg+W73Bj4auQ6nhg", - "q74L9lEoJ2ZV+JEbrNLhm7eR9J9jKoUOkOzli6Sc0cmOe3JJiPlspVWdjtxeaTQN9X1B3SMABSx6wJNz", - "2fnTb75lhViBsWfs75hcjy7fYV20LjaZaOutdUp5MgSsSdBKYpAPRozmXHuEDoKDhQ9KxGEeHsO3yU8+", - "n6FcktldKsD95UBmYZWP4MTcohG/6bi930dYu5BWc2K+mVouk/l2/4a/t24ROvBkDUOsT+DK17DXcFvZ", - "5a/YuSkxOs55SuQ8WGvndoynBD4SOVDuEsfn66dZe4LO2CvXm4FcKu1e1ZsaLX2ww8R83uAWS6mYvs62", - "5aExc538HbRCpYFkyhu2+2es2WyMsuQ5yvPGRxE7GJrEuo1i8tE7lGbmBORjepMOjxqrpRUk/rht/CXa", - "xcpdPA7ov69FmaCCSrnvJoZjzqRiCp2D4paU1qDNukgw+7DwDiE97DGP04kXaVO/owSMh3wV1dZoNRL5", - "msu2YvvxkgxDmpxWk3lQlChxzNMVI9wCVrSA1b3A+Wkd9aQaCQ91H1AM0UAZEhvt2QMnA+L7DUh7S873", - "hnqTbwLWs9WHXwB65AUQeh+rA3wN+8yq9NhAhiWSzJunFupJidtGa5yPvHuaGLtQA7+VXekEORFhWaNB", - "NzJdBj2pf9I1/mTXsG+9XeJagfRsusUri67FtBb8UmygfZeQIJcSgcSkK5Gel+l3LeVEIpb9xYHlNMMc", - "pgozQhXU9zBNTLbzRmQbGXoHeY5ucQoiNyTMxXEgzGNfQTewDx0TG0VdJ8kF6gzO2IsmSQz6IVKsfZs5", - "hvRZfW9FyojSZEkWOui9uA76anRoRGc3PDUJRuAbkGzk2gylJN+E50tsMKYICs12S9Btu5QyJrRc6t/b", - "hkM9UGhWVehZMKLR8q2MrdA4NIbp1imz4vtZEAZn85lblvvHge3+Xerf3T9VVWKV02o59MlMH2BPExnO", - "kwhxn3VfrR1BsjmJLWkd0YAerKPnA3eXVIO3uVVPVU/GCnRKR97+8JyX5eVOej/AYdjbAc9LXlHo2yvv", - "cdlwaMfGvftu0Fp57hBbYnieOxGvaFM+RHB+YVi/bgolghhWTjngjXmUQ/dFgJg2uV6NrhsVVkMxVOSM", - "61VN6YceYH1HVjDysuGVKHxCxmEhOy+yEVuoNRRMaZ/KSyx9nraxSg7Hy1TR7lVeZhR5Kxq2WShGKH3u", - "Hj9Q+WTrSmZ541nu7kn3wrSKXZFH9tXsjL2knDEaeEEMVgsLqTpKnfVj8tstYFnnQNFZg92oCt6ZO0Wd", - "mlsGKVsD+k8kSqT9S9bjQoyZegRjY1yJpKoukj4Bhp4Pi4lhsQCp7L8QniZV5rq6eg8VHqxu2Ys4jqKq", - "mmJdJbh9/63GADjHsHHYER2t0iBWcqQWOxLIkoeLwPTRlbwOulzKpxuMEW8Gt0Qjjt+OiaLlhQajFAK8", - "yLCU/QGX7wR7bfZipDg8Mbgm2aRpY2+MX2VUA2PaEgObeROtEAk7iLL3ub5blFS7cx213gAdrnGsbyfA", - "KFF5Lb4L+0Mfk8wiK+dByYxKNpRu4cSfNGTh/gwcSxZUzaFu45Wu5DP2O2jlH6vNUO5AtLpxnwbc50c9", - "S3RqCquYQbf+lCcWrKHFH5AORwtAXV293/GBlIEw3UG+uF0Nr6M4/mGklEiM42Aq8zVE7lgJiGY8sLFt", - "zOXQIsYL3Neo/kLs40VMpikoQLvta6ogsfDtSBmTg9hcHsTmgfE7GZi24XVI6YfT7NO/JinX1TbsOPVI", - "xXWOxyi2FaWGU085/I3zwCTSCC/kuxJHmPUAeYyb0jknL9FnZER3rzLjBa8A3xnzLCSdyNtAuQzcLNjm", - "gvU4pjR3M9G9tuHVvVaPO8o8IojHfQ5g1OOgzWvmL+ZEKnMaofVtcLJmsEYmRMYT1x5GT6MQv/bTWfG4", - "KoRZq7osqDDEBnOxtW/MBHZ8AahGLmwLcpEbB3pdxEHWJpoh3mzGXrqRebnlexMUtS1ljQ8XdpXKRySU", - "hHGyRtIup/dG5+QmDrmoBEjb+NzEeHFEPq7eTA/s1aSO61AWOXHTaC284z1vK6l1TW/B8uarRfHohp77", - "beZlV11AAwdVtGvzPIwdVtSgNLrQjqcUSdXTa7b0CNPzttGD3M7rFU9lctSLuBxNM87epJLdAOARo4x0", - "jRzSXnN93bkE/WH1A8gVpRPojNqRMaIkAAZKSkXai0Eei5AxUHpTxpt6UYoczQjo9N0YFrzHf8Heclmo", - "DfshJPN59MvbHx4zDaYubSCykNnYEZ+H5NOWExhdeKWXfuXvomiZZvlCeovKShirE4rLB18V5nw85nDk", - "Gi2Nbb2OyGBN6R4HAeHCc8H0NYQTXsM+K0RZjxKya3VddBNumnqBZeGEpKy8C25z9GYZgGAOTH3Ew8G1", - "KWmp6OZw15VOOzC4XH9iOrNUvfPzuRHQkadEMK8e5p7ecnMq+/TdiH/6mW4nH5J42IZJRImAHT5DQZTe", - "xX8nKSuaguK0nPRhfFXCVtjqupS2RT9l4xkaGRKOupx2x0u7nQY5CyfBwmdiKHG5CfH293dLKxlh/8IX", - "Ky0j4WdZy8L0trAth3/A/npQ9vGiT2hz0JQ7JhRMlQQ6QbNdSNBw6YNO2nhpY1QuWiM81pqkqpJ/k+Xe", - "J6XrV/Rot7LS6kYUqUL0pVqJ3JAK5lSL8avQ98N8tqlLK245zuvQl0zY6etQrPxVKAuuCwbF02+++erP", - "3VQInxG7Gm5S0r3HL8trGbkVeVeObVY3gYkFVJ6t1JBljRrb9Kq1PTTGtVTi1uk2MgRkPPQ9KFq9g8hi", - "z3hE6sqJ7aUV7U9z99uam3XLOqOyxVhGmjPPr/pefxhfFBn6Hjj83BN2difHjN7xGGMc7SH5HM5GzB6J", - "HqayxNcRJxmscOOXSHpXRy8h6BL3uirByXYtDxxNoxNQQ1d+mPOdGFb5j8dL7zo2wNKBykkilJfVCZOt", - "xIUKghaqW3gHD/bnXQxXKi/eWoNxEKW9b9Y6mWnkUP7NNvNhIq/6Sbh919vTXmYS3LdRCbe6/kQJbA7R", - "wOeRxSHtiHVYZB7LxcCmBOY1yaj6SajGpecoK+wh0h/Nt9p9P0/PaOLB6Xu5jbmnmSo4qF1GoaNxhi72", - "ksi/9WpEOVZSvhqfco+Mv74AQHe/7h6S/wEjBJaKshtIy3PbphafPfMjzXyR39na2spcnJ9vt9uzMM1Z", - "rjbnK4xyyqyq8/V5GAjTSHZSp/kuvvqVu3bLvRW5Yc/evEQhWdgSMGACURcl1L2YPT17QqkXQfJKzC5m", - "X589OfuKjsga6eKc0hy7/64ozMFRDUrCLwsMQb+GOFEy1s7GVMjY/emTJ2Eb/DMxMk+e/9MQQ5tmMY2n", - "wU3ubsQjtKc9jgryJyooy2uptpJ9r7UiBmnqzYbrPUZA21pLw54+ecLE0qd3psQf3Ilp72cUkTv71fU7", - "v3l6HvmJ9X45/yO4aIjiw5HP57yqTBYZkI+2D1b4g60SUXzT+0yaoVeAMrRNzxf9ev5H10T9YWKz8wVW", - "ipjaFKZOf+79/EPb/uLx7/M/gmr5w4FP5z4txaHuI/tG1WbO/yD3aVJVRFOlO3XY/h9256FDja52x3x2", - "8f6PHp+BHd9UJSCLmX34tSHvhkN5Mv8wb34plbquq/gXA1zna+y+y5QWKyEd+W75agU66zGY/x8AAP//", - "+ge3+k7gAAA=", + "Xq6U5rLIlkpvuJ1dzJ75fh8OfvYzZFqVMFzjc7VZCAlhRdAsqEEOs4oVsMRGa26Zg86tMzS0ihngOl+z", + "pdIHlklAxGsFWW9mF+9nBmQBGjGXg7jB/y41wO+QWa5XYGe/zlO4W1rQmRWbxNJeesxpMHVpDcO2uMaV", + "uAHJXK8z9ro2li2Accne/vCcff31139mtI0WCk9wo6tqZ4/X1GCh4BbC52OQ+vaH5zj/O7/AY1vxqipF", + "zt26k8fnWfudvXwxtpjuIAmCFNLCCjRtvDGQPqvP3JeJaULHQxPUdp05shlHrD/xhuVKLsWq1lA4aqwN", + "0Nk0FchCyBW7hv0oCptpPt4JXMBSaTiSSqnxvZJpPP8npdOF2mUE04Bo2ELtmPvmOOlK8TLjeoUrZF+A", + "zJXD48UNL2v44oz9oDQT0pq5xzX4hkLai6+efv0n30TzLVvsLQzaLb7908Wzv/zFN6u0kJYvSvDbOGhu", + "rL5YQ1kq38Ezs+G47sPF//rf/312dvbFGDLwn9MuqLzWGmS+z1YaOHKcNZfDPXzrKcisVV0WbM1vkFz4", + "Bq9O35e5vnQ8cDfP2GuRa/WsXCnDuCe8Apa8Li0LE7Nalo7Vu9H88WXCsEqrG1FAMXc4265FvmY59xuC", + "7dhWlKWj2tpAMbYh6dUd4A5NJwfXrfYDF/T5bka7rgM7ATvkH8Plf7/zXLIohPuJl0xY2Bhm6nzNuPFQ", + "rVVZENFHFwArVc5LVnDLmbHKMdal0l7iIa479/1bIY7liMCCLfb9lrLojH64j9sf2FWlcitb8tJAer/C", + "6uNNwlXGsgUvy5m/sZyg5afMmh94VZkMV5wZyy3EbarKtZBKQkIAaX7gWvO9+9vYvZOykLXOWuxkeakM", + "ZFYdEMCCTIUbFolM8Y6dJI6xyzUwnNx9IFEUKVs6Ll2We2Y9AhxBsCB8zZlYsr2q2RaPTimusb9fjaPp", + "DXPIR5R1JEXHzcaIe7AZCdJeKFUCl0jaK63qKiljvFLquq66Mvliz7ADe/liDIBmwGl+uwZegM6ULPfD", + "qX/Ej8x9ZMuSr87Y39fgmYiTOdyu0DbMmQZba+mou1T5NSsUGCaVdfKK5UL2nwpmBOwYngNb5l8rmSP5", + "cbmpDKyAmjsRCXFSNCLVnBVQAtJFe27xV2O12iO9uNMzZ6py50TVdshPZOGHpc999oJnbfRhFK/kwKJL", + "sRF2uNzXfCc29YbJerNwGFs2MpZVHjV4PjSwHMl80WGWFV+BYeBEMEGvOpzHIdnhUAPP1+OMnGA6wLs3", + "fJdpVcviiMeLZUrHwqGpIBdLAQVrRhmDpZ3mEDxCngZP+6SKwAmDjILTzHIAHAm7BFodR3NfEEERVs/Y", + "z/66xa9WXYNsbmW6X4BVGm6Eqk3TaUxKc1NPcwmpLGSVhqXYDYF857fDMVVq42WCjZfjPQuAgnk+4IYj", + "Bj0KUzThqY+VBTfw7Z/GJPX2q4Zr2CfvqT4B0HIa7cjafaG+06toZjhwqI+kQxJLYvqbpL2j6A4bZcQ2", + "EmKl++qZSloT1el/hKgfz016kOxOOikaI0gEY1vRm+njPX+NWGU04uCUiNWlE1+WokTR5p/ucATM1sbd", + "S13cBmHHiJXkttZwcSW/dH+xjL2zXBZcF+6XDf30ui6teCdW7qeSfnqlViJ/J1ZjmxJgTeqosNuG/nHj", + "pXVSdtcsNzVF+JyaoeKu4TXsNbg5eL7Ef3ZLJCS+1L+TuIpXoq2WYwBMyUzthuYdPeViPyE54ZBT/BB5", + "h6mUNIBU+4wEibf+N/eTY3kgkaNHssD5P43Cx1s7dqVVBdoKiPXC7r//oWE5u5j9j/NWj3xO3cy5n3DW", + "PA7t2FVGB5hbz8KIdXmmRsLApqotXe0p7tAc5/cNbP05W7SoxT8ht7RBXTAewaay+8cOYA+7ub/dMp2H", + "0JH71n/MfMR9pMs9w0t6OPLPxj84K74SEhc+Z1snZm/4teMKXCq7Bs0cLsDYcM0T+6Obv1Foe1nBv1HO", + "ZqkTk8CpuTNSW6y9cuLuOxR37wPFvefqCbhOgfRvzDeYH2zsfZLA6p5wP6npv7p6z6tKFLurq187Ly4h", + "C9il8fFRkV2qVVZwy29Ho6sXrmuCQD9nGupaUe6LgO6XeE7AwsPeqPe1Xfd82G7FY//NWROn4u5M1Riw", + "3/GSy/xertOFH+poDL8WUiAQP5Kq699oDmhutvI+UOx3914OMmn6jz7C/0Zu6gw39pM7o/a+UHoUIh/4", + "RYhT3scmfSrC/zfF3y/Ff1eq/PpWuJxCFY56aGa1u/951S4163dqx4Qk7Z+XfL5TO/hcnzwLB9vRx+I7", + "tXvhp1T6X/s1Qgs/hoK/8/44Bo3LMt5Zt+TvtVb6HrAb3oY9eOazDRjDV5C2vcRrDA2PWVQAGBECbgmo", + "of4ReGnXz9fwEQ5qNPaB43rZKmPvYWM/KsuO9MaH1h+t6sBjrzvsiVw2msZ87rv3+bCLzpYfzxA7OO2z", + "w+NxbE5D8odgf4gNDAlXQu8rHl1HDlPcu1OSefBKXskXsBQSrf0XV9LxofMFNyI357UB7R+YZyvFLpgf", + "8gW3/ErO5v0LasxWh65fHpqqXpQiZ9ewT2GBfNISIyjLy8iBIXJP82bj1gIxpDMaNXPkoGqbeW/YTMOW", + "6yIBr2mM1jgy+clNzTpnfmyyrXtvWz9+mvYHvlZDX/9JNzQhu35iDpE/Kest0HzLiJBYbcCwf2x49V5I", + "+yvLruonT74G9qyqWs33P1qnNgco2r7uVY2Oi0UcZrCzmmfoU5ImFFNv8KYtS4Ztuw5zWq0033iflL4r", + "3sRO0+TH3VTRsnBF76jXh3n0jOihCn9nayiHDnynIiZ6c98aLwfe7RMu5ZdR5ANfcSFN4O1GrKSjau9F", + "ugCWu7scijP2csmQN807gRM+BMTzvYYBCEOOn+zSrQtdJFjOJTqEVgW64AnJuNz3jbIGrA2W8LdwDfvL", + "yMPiREu9d8fiBy62onbDNZdbi1W25YZtFFrpc5C23HsPrwQJpoGphbTkatJxsRwAEjk8ulMR6Q/HXEYj", + "ZzZeVWxVqoXnHQ0tXjTEGPqMs4k3DgBzDywi+Z7uuqAeWj0dszFX2dNX58a70yGbXNOtiWsptEE/QeCe", + "1fP4MNyCxrwT4xCUv68BpSil0ZmvS0cmHN4UeTc+SuhsCdKKG8igFCuxSMVX5bxzYwYPW+8R2oxgmFgy", + "YQ3zKlQHhJBMc7kCJ704iUMZXlI0SBKakhubrYFruwA+4jeHiGkd1DvLdv3Z1rEsJUshYe42B3aOjoXb", + "CQ0StlC41Qjt2zB3h9cjVz0CRICnUHAUPKE77iHuWXqujZCZ37qEI2iQX5rdDQJqcAuMjxLCRd83gIET", + "auvw4qBQ3ud/4NFeuydoGrSKaytyUR1ndyNA3nT6uEEOyW5JaU0t+0LZQH5KgkyNM7fm4Uy1IW9xt65w", + "2YXR6d2DUJ8xdFXzm7Qo0YG8idgifHONnu1hqRTBNAaOGROPw+TdtceHbs1NOHgYnxHuiaMk1hFm1pKv", + "46MR/cbvDuHmLeGGj+30uG8c+ob33d1QhBjGVwSnUopADT5xwREueL+5fx2/q8vScZtaXku1dc+ZU/zb", + "5jM68kOAbxSKKfQ5EIYH8QsTocbB8bflEvlHxoQs3CHCRwe3IVxG5YKiElqe7Hj5yv145gZw1OUGOHqE", + "FNn6IVHCVqqkgdlPKj5/cnUKkBIE3is8jI0XTPQ3pF/hKKajxE7+9EKmKS4Pp9y9EzpSEQKGMU4LAElu", + "+UzIOXOs7IaXjpVZRaJpM0j6qfWo80rygrt5PPYES2uIaEUouZy0JpJ1brOaWPwPQKffJhMQL9Quw5jB", + "IawY+ldVWcPElCz3FGHTf6fjCG49KkcKCV7K17Cn4B4MN8NTghpZzz8WUCon6asBhbWIOgD8XQG/R2im", + "BfwUNRskPZK8W7KbCBE7OPWIfD1Gdo+Qhu4AQF//3jhXew3PQaVMV5QZXvztbThvndmJI6fZyNhRHBJ8", + "l4qSWBzZ36Ear/FpfdOXfpLKuk4rRk0WXg8VvYVSt59jR7mSBqSpMQrTqlyVZwMtnYES8BmRdQSy7BoS", + "QV7vQuNIb8ceiaV7nz+OXgcaVsJY6MRHNvEHbXjFHmMKK24taDf8/3n0Xxfvn2X/zbPfn2R//p/nv/7x", + "pw+Pvxz8+PTDX/7y/7o/ff3hL4//6z9mI9cyOHFbLdNreqtUc/FhY4aNO0t7cKhvlIUM333ZDS9T5r0f", + "8FGYlLQ6iGQUxCtGdO440TXss0KUdZoWf2q4oKkXyKmFZMAdJ+Q2X6M03ZnRtZmYDd8/I6t6xe9tUUeQ", + "s3ao7w78L0LXPX46dYgTxJRC+xA5o/s4wdZQMnoBJRkvx7Nt0EErXMOzKcPB4GAUYeyp12IExfjNQyMl", + "19L1Bx1fBVrSUW4RNor3NYMVHasD2jYhs7EIuuWNkuuj63ri1cX6Hj9KWsXiP95hecPhj11eMi3Scd4O", + "iLBTVJYkAA1oCs+KH+wAPUV2keHl6p4Rxj846IBEwiXFwcu+kNmjsyas+DhcBFnBRzmrurkJp2XZ+6M5", + "SDy2aO0p8mNLrTZ42IayZqyAHNFLdKiuvVp6s/p0TUN6cfwSHygH7cDAy7/C/hfXFrHqegcJ89hT0qpp", + "wisvvDjuhJq72bxSlO9HPEj5FLQwRvaY2IdsEx0L9YknoFQrk4rxW7UhsTEVLMA9imEHeW1btWdPud7o", + "/x9WBuwbEtLhi5HPASWXmpYUcH/8WAcw9qZhjx8TYbyqtLrhZeZtuUluji2CtfeBZa30gbr8/tmrNx5i", + "NCAC11nz1kgvBBu1b4zPdi1O1FAHjMGoiAoKgP6V7o25wnQMwFtMKdF7ujrhyVMRbUxrxI+OqTcIL4Oo", + "faJ51zsZ0BKnnA1ahQ/5GnT9C/gNF2VQ2QcY01cFLal15Tj5togHuLOfQuRXkt0r/x8c3vRJOMBo4hkm", + "MkZsKG+JYcpnhmiR5R6jaBRAstzwvaMWUssOOY6sN6jZyUwpUmaxrrqSYauR96wbyl2tU4O47+YInVgP", + "rGjw5PYFP/+x3Voo7+xWS/FbDUwUIK37pPHM9Y6hO3UhcdetXy8JCzYl+HrA9wtOeMrLxeftudPimlFu", + "835x75OENZGw5tfT4O4u75hWhTuU4xCI6UdM7EQ0APdFo5oMVNRYGLjsmJFP8C6MZxyIDSOegdG5k8Lb", + "OW6BlcNpPMNDyed1SvOHk95BcZqoO71+TLbU6veUF+12OG00IfVKD3r066V3TkZeMaKXZu8WKGoSbN0V", + "pObVe2eg+rdjY9toc7u2yBk9ZGNyd2yD6bqkjjByPG8YBsL11dWv9LAMdl4u6YA9xxyxnSdP+pjGDsrn", + "NH57TD3MQ30E3y54fp1YTOsV2LFEW8VCpyZlWhc7ZyxyMGza+uxjFeiNsF12376obivZ0rRHy7StCIvU", + "FAuvPudjaVRimFpuubQhh5xnYL63ATLpuF5bpY3FLJrJVRaQiw0vR8x7LYMsxEpQ0rfaQJSyzPdnlRLS", + "EtEUwlQl35O7ZbsjL5fsyTxiXh4JhbgRRixKwBZfUYsFNyiLtBqm0MWtCqRdG2z+9Ijm61oWGgq79tn0", + "jGLNowMVNI3nxwLsFkCyJ9juqz+zR+jlYsQNPHab52XK2cVXf0YLI/3xJM3LMd/pKG8NLD1NtejTQ13d", + "pegHS/Nayu990pmhLsecGGzpGf7hE7Phkq9S2b4mYKE+rV2/tw+yoFSdKDIxYdPzguWO62RrbtaptMi5", + "2myE3Xh/B6M2jlrahFg0VxiFbPrErhtwwkf0QK5YWrn2sBqfdA7on/gGups4Z9wwUztQW6WVZ25nzKeC", + "KygXZ6tNxC2hVNLkkUY632WU6Lm2y+w/Wb7mmueOlZ2NQZktvv3TENLvMF8ew7zUUNBcxwP+4NutwYC+", + "Oe6gBTHJ92GPpJLZxrGH4rHn1N0zN+rOlGbLfYeT6SGPlZHcKNk0VfGIy96JvuTEgHekuGYZJ5HdySt7", + "cAKsdYIafn77yssDG6Whq1tdhJiijmShwWoBNxh6kcaNG/OOKNDlUZt/F+g/rQ09CIeRABVObEpUp0Dz", + "4XZ4//Vm2WOPXqWurwEqIVfn5L+NwjSN2hejF0rWIxrLSjnZSfCSYSNW8b3b5UYEnfANXwKYLFdlCXny", + "jdqLvnLNWcUFHZs4w2ZwfJyYawUSjDAj1/nV1fvV2r1Q3Gd3E0daFgoIIJ878/BHNAA+EmG/Aungfvni", + "ENSDgbtuFRTqdFCH0/EH+9n3cYP59L0Zzju+y66dg/dNSPdLcLr2D7+1PoZBjxC2/9rw7z51Hav8DwNl", + "dDTGwlFtzcsQ24nUvQTtC6d0wEEdDJa2AGBGyOuDvvkH01W89W3Hneqvrt5rWTjMPffhc+Qj1bVjEzK3", + "HO0SIIsW+nzNxYhPqgFIT+g+uBnfKW0FOe0AfGIHPqt5fp1UQF66L6Zx4iNP+8idzxwdyIXWiDeuz2WY", + "LWWMFRswlm+q5N5Z43aO7gK8V9z2NV0cwzSQK1kYR0E5MKiUWR/KKGDSU+0kTlYKQ7JOzJlzpSn7LMqu", + "VvWivY/dksm49i6MmVbKjgHq4OwkJFDKMl7btbvCQhwBYK2A/koo+g3frTIKemKvnZQR8vbystzPmbBf", + "0Djae3ZytgF9XQKzGoBt18oAK4HfQFvMBEf7wrDLnSgMliopYSdytdK8WoucKV2Apio3rjm+pamTn+/J", + "GfNRvT4O4nIncXlNcYN4nbTMEL3SWLTiFc9JhOv/jDUmDJQ3YM7Y5VYREKbNbWCc9NstAFFbihksxHIJ", + "yD1wOfgUx37thwgmLMuCoQbNsH5ND88DBhSWmTV/+s23Y4T29JtvU7T27sdnT7/51knCXDJe70QpuN7H", + "zVyrOVvUorQ+0TZnN5BbpWONg5DGAi8GtEXaKD8LyjLLWubeDa3pEhfPeffjs2++evp/n37zrVdfRbOE", + "KGgfYAfyRmgl3aegMGwoxE/ZzAY7YewnkJbsTmb4Xk7d6g41OaJlJ59TI+YDL7rm3B4L25B+Khz8EooV", + "6Hl7ETu+2uYccY87pSMJeAkUIubuRSGtVkWdA2W6eNfhGxFYYgBSUz4hcrfBsx6qF7VwBk1qI7Mw9hJf", + "wE/oQSZVd4V4xuAGNMX0tAM9osshgstYrtFPCd2W/FKheJy+2utqpXkBx3kh4GX1M/VoEjeEEW7UaQP8", + "4tr3H1idN0BHsk4LsFEgh5NR4js3dedMcInR99vbsQjKH6gikIaSQt2wMgq2nQ9eZ0uAzAmCSYp3ryZM", + "wJXnUDlKjytgAri7hk46nmWszBeEtiYImoLw0hoshCnLeZnXJT0lJkTIbc5LtAS1hF3C0ipHe3GFr9YU", + "INxcC/QQp5IiNJ92d1jUA9NG3YDe+xakeQkVPNy50T3XnaGonJVwA2UScOAaZYcf1ZZtuNw3uHBTtGDM", + "o8i4BnISgtFDhLD9s1cKReDTOfMEOQ2kQ8XI5hYxnivQQhUiZ0L+E/xBj58OSDFUCkhJK2SNRac0tHDT", + "Vc8wRLcfhjukAJ10KXZwcQsOsDaKQ8K2g+0ieih0gyGM5ddAYIdgYi/dHItTDUYUdRqypeZ5F7LTiNEf", + "3rfcwrluUGvuiS57zKs55FOHrk/LPbLpYWu4S6N8qsOXj2FWvIn4Yp6HJ5zFfQaq0HJEY6Cswks7yt3S", + "jH0D2nTdkCMzAewOjO1adManvFwhtcHps2TBH82MzrcndtzSXJCfKfAe+/u0CqkdHEla1gBgtsLm6ywV", + "OOIBoBYOhrf9J/xwSpIu8BTCcgm5PQYGjNqhilijUNBnB8UL4AVGjLdRVxRv1Qfl0U+KuaFNJPJII/Ah", + "0Uo8OMrjExKaNxRyiPh/UUfSvg+4R0+II45BkHE87pNb5tt44nnZRL1ztgeDu9J4l0dnBDOTpE28YdIC", + "Sr6fmhIbdCdtZN5g3KY7BxN4uAuFvNlHg5DD1P6cTU3umvQX3BzP4amIS+0MMKkSTm4hl2YTQuWzEiZ8", + "NpM2LEfMfINkHMrkztmiY5B4eKPi/aTFSMc1huCTwTbgl7AP+Ed/Iz6xdSWU9/X3JK3k1zShREllkyRT", + "NN+jkGiKM8D1h+R73FevPZKaepasQFGfwb6l9un7G16OBFq+hUqDQT0BZ5ffP3vlnWLGwi3zdKTj1dV7", + "bh1NYT82mmzqw3w2khni6ur9Ajkm5X1osDG0LiZ9qB0jEq67+zzofTuXvLEkqtGGBl/8IUB/DQFgrOLC", + "O3q1sabDnfVBx8Po7mOCyFoE9xfho3pHj9CP3Kx/4LlVej/M4Oqe1iOpda6u3jt8n7LFX32bZvcOhPQk", + "l1H+nq6KrPH/Q9+7IA+p5SCPD8NEPmvuNWfhT/fSj5L2NN9n89lAD9DiIs5DnPAzWuNnym3IQiW3IaZH", + "0zUXi6wJG0lVdJzPfLrlOMfswVAwYbKNWGkUedKjjqeJjq6oxA1DonaiHLMXa8Zl8R6Rdhbeg7gFL7oR", + "/Mwpgn4pC9iBbi0zr9vV9SzlpD7CwsAma5Wpad5ExP6w8gHF4bspjIViQluzPPEoksdP6cS0o8Yvbze+", + "zFBMltkWxGqd3tg3txraidGHkXbz8EhLMbjXqPV/5g4kUuQIo122bHgyGXrEsdE3wI7Y7+2alv+5hKRq", + "cG+YagRcW5xICP85stn9ykIJRm3EpirJ+dOzkkHuq5MSTbQBJh8/Xum+gz4+evgG3Noj8f6jNm4Ly+GU", + "VNOxGn+Tz9WmKmFceK64JPF5KaR/t2/X3MbF1IMNSOV5rVsjbj8a4xdeCqryazCLoVSqwrSFlRXS/QcT", + "OKja0v+Ba/cfcirq/o+oKpKT3FAzxAsmvwoDhUjO2XxGnWeBspNSVNIxabAp3XRWAZ/ohI22NAlQYEBC", + "m036nOeW7J/eWVOC3Sp9nXjGLAzqkzp+VXHZ1yE35drWFacnCm88KHwK1yYrXAOah8zUhrxrOv4TB3kl", + "7CpHa6cDWOjNzZEQNpun5A1ob/tQPqckWTkoTe0gYRPz4J2yphSrvmUCoKPcUIYvtMQ2t0IiqQbTvk2o", + "1tLxOznyFRq6bOZ6X1l1jm2wybmxus6tIa/Nds4BVbqNJuelw/Xz+iKFkwSUEWTPtCrTcAN8TE2Prlrw", + "Ww0OyWiqc41ZM0AKsccy7f4e09jprUVAYlcYCpoiB7tyH5JlcrfnG169p1l+ZRl7SxA3pRTQI29jVtXp", + "nls0VAp0w0ubjb5yvHzJ3vHSxmKEA8j7eTQeMuOJa0mCTY6ef4onh4Pp9iToFgzFlLi/vYW4P8o7cN7m", + "oiAJrHukbkBTLPTR5PBL6PFhPnvQdbxtTuyQK0TrO24V8aZErCGtYglfw3FqUyVzWbBofsPwbCR8BfHo", + "grR6f5s0Q2KVmVKdsLx3YvXOdTiwpaHZYE9LtQWduXknUFwGUyPF21DLTirpppYLjUeeElAwtxhzu42g", + "gU/aCd/l8F60Y/ecUniZK5l1Zn9YrkP8MkPqyposBwd2j2+6u1eFt/WpXAuZxF7IVTrzo2P017D/PHQJ", + "CY/jAT7RxDuuzMGHxk+NQ0NkZNp6IzIZCbuCzoEqEu65hpKmL5czca5s91y1/kUbkWvF0RmjTTkNAwnW", + "P/bQl7HZjSkHk7RymRJzU+fLfQWNU+6w1M6GV+G9he9wJwSffUylFXvbuCMPPUpzJS0XWFAnKdyTMy6U", + "FTKqVjd+9lmR7y/RzdzzNZnen3yDBBQZrmL/bff/4ZZZDfDwHq7XsM9KsQQrRgzS5dKt5K+wZ6HZ2b3J", + "FGM5kjoGP9Q8lBQT0OZ9YkrTlxV+idNLMeKjGCRtwl+GFWBBbxwprtWWbep8jbI7X0FIsIQGG/Qs703U", + "GT1kpOimB/PxgabiOQ1EYf8l1yvQzEfiN3VJggFowwWek9YbuB+fi45iPGWMO5T26TWlAoh4F5pOoxxQ", + "iexSAYxr2J+TZRB/vwUjGU8lNQIY5pX6iCDdKT1VnNPsAL1ed4yqVOyrk/ytAf8ejasOPq9CONG4OszW", + "duzycB14HGoDw3UeH40T723iiduu7VjPgOHmjhj0D9nxR0q2eHMv8nHsyxA+9o+v/sE0LEGj3urLL3H4", + "L7+ce3+FfzztfnbU9uWXaaem5Mm5P7+BphKAG8NPl6SObgHYng2VLnlD4bTkuOYuNCXRZbMseyFPsmCY", + "bADFE44RIFCqCpKtsVhZfINiAjgNq7rkFOojpATd6XRMph96/tud9Kou/PNyJ1NtY3ESW0fbkSoQGlVh", + "vl3l3F45OcqzlGNGo9uO2OZEakek7Cp3GfEHSunSjBgiTO8y5qUf40AJx6ur92YlUS0XlHEiZAlAAZgw", + "3KWmJnNAKPMYMhU14WzwW81LH64nMTjuEtP25NcgqYKj43K++i4DaWrtVYIOVhzPgeKHUfFlbtomt63l", + "OF4Q7Orqvc5J++s92n0yCMw8RV2dmFE45KjpoiquvXtijiWjc5Itd3P5hiG+GH1FDz29kIz1ZtyG38sW", + "HUeWYMbF0H9k+LZ+SVsKPZ2LsE0q2buZKf/9o5cvHjPRL4YeZ32MHlqHlx2XUDkOIsowMoCln3vyFCiW", + "AGPhPL3AQraEEVXwZPkONxa+CqmOB7bqu2AfhPLIrAo/coNVOnzzNpL+c0yl0AGSvXyRlDM62XFPLgkx", + "n620qtOR2yuNpqG+L6h7BKCARQ94ci47f/rNt6wQKzD2jP0dk+vR5Tusi9bFJhNtvbVOKU+GgDUJWkkM", + "8sGI0Zxrj9BBcLDwQYk4zMNj+Db5yeczlEsyu0sFuL8cyCys8hGcmFs04jcdt/f7CGsX0mpOzDdTy2Uy", + "3+7f8PfWLUIHnqxhiPUjuPI17DXcVnb5K3ZuSoyOc54SOQ/W2rkd4ymBj0QOlLvE8fn6adaeoDP2yvVm", + "IJdKu1f1pkZLH+wwMZ83uMVSKqavs215aMxcJ38HrVBpIJnyhu3+GWs2G6MseY7yvPFRxA6GJrFuo5h8", + "9A6lmTkB+ZjepMOjxmppBYk/bht/iXaxchePA/rva1EmqKBS7ruJ4ZgzqZhC56C4JaU1aLMuEsw+LLxD", + "SA97zON04kXa1O8oAeMhX0W1NVqNRL7msq3Yfrgkw5Amj6vJPChKlDjm6YoRbgErWsDqXuD8tI56Uo2E", + "h7oPKIZooAyJjfbsgZMB8f0GpL0l53tDvck3AevZ6ukXgB55AYTeh+oAX8M+syo9NpBhiSTz5qmFelLi", + "ttEa5yPvnibGLtTAb2VXOkFORFjWaNCNTJdBT+qfdI0/2TXsW2+XuFYgPZtu8cqiazGtBb8UG2jfJSTI", + "pUQgcdSVSM/L9LuWciIRy/5iYjnNMNNUYUaogvpO08TRdt6IbCND7yDP0S1OQeSGhLk4JsI89hV0A/vQ", + "MbFR1HWSXKDO4Iy9aJLEoB8ixdq3mWNIn9X3VqSMKE2WZKGD3ovroK9Gh0Z0dsNTk2AEvgHJRq7NUEry", + "TXi+xAZjiqDQbLcE3bZLKWNCy6X+vW041AOFZlWFngUjGi3fytgKjUNjmG6dMiu+nwVhcDafuWW5fxzY", + "7t+l/t39U1UlVjmtlkOfzPQB9jSR4TyJEPdZ99XaESSbk9iS1gEN6GQdPR+4u6QavM2teqp6MlagUzry", + "9ofnvCwvd9L7AQ7D3iY8L3lFoW+vvMdlw6EdG/fuu0Fr5blDbInhee5EvKJN+RDB+YVh/boplAhiWDll", + "whvzIIfuiwAxbXK9Gl03KqyGYqjIGdermtIPPcD6Dqxg5GXDK1H4hIzDQnZeZCO2UGsomNI+lZdY+jxt", + "Y5UcDpepot2rvMwo8lY0bLNQjFD63D1+oPLJ1pXM8saz3N2T7oVpFbsij+yr2Rl7STljNPCCGKwWFlJ1", + "lDrrx+S3W8CyzoGiswa7URW8M3eKOjW3DFK2BvSfSJRI+5esx4UYM/UIxsa4EklVXSR9Agw9HxYTw2IB", + "Utl/ITwdVZnr6uo9VHiwumUv4jiKqmqKdZXg9v23GgPgHMPGYUd0tEqDWMmRWuxIIEseLgLTR1fyOuhy", + "KZ9uMEa8GdwSjTh+OyaKlhcajFII8CLDUvYTLt8J9trsxUhxeGJwTbJJ08beGL/KqAbGcUsMbOZNtEIk", + "7CDK3uf6blFS7c511HoDdLjGob6dAKNE5bX4LuwPfUgyi6yck5IZlWwo3cKJP2nIwv0ZOJYsqJpD3cYr", + "Xcln7HfQyj9Wm6HcgWh14z4NuM+Pepbo1BRWMYNu/SlPLFhDi5+QDkcLQF1dvd/xgZSBMN1BvrhdDa+D", + "OP5hpJRIjONgKvM1RO5YCYhmnNjYNuZyaBHjBe5rVH8h9vEiJtMUFKDd9jVVkFj4dqSMySQ2l5PYnBi/", + "k4FpG16HlH44zT79a5JyXW3DjlOPVFzneIxiW1FqOPUxh79xHjiKNMIL+a7EEWadII9xUzrn5CX6jIzo", + "7lVmvOAV4DtjnoWkE3kbKJeBmwXbXLAex5Tmbia61za8utfqcQeZRwTxuM8BjHoctHnN/MWcSGVOI7S+", + "DU7WDNbIhMh44trD6GkU4td+OiseV4Uwa1WXBRWG2GAutvaNmcCOLwDVyIVtQS5y40CvizjI2kQzxJvN", + "2Es3Mi+3fG+CoralrPHhwq5S+YiEkjBO1kja5fTe6JzcxCEXlQBpG5+bGC+OyMfVm+mBvZrUcR3KIidu", + "Gq2Fd7znbSW1ruktWN58tSge3dBzv8287KoLaOCginZtnoexw4oalEYX2uGUIql6es2WHmB63jY6ye28", + "XvFUJke9iMvRNOPsTSrZDQAeMcpI18gh7TXX151L0B9WP4BcUTqBzqgdGSNKAmCgpFSkvRjksQgZA6U3", + "ZbypF6XI0YyATt+NYcF7/BfsLZeF2rAfQjKfR7+8/eEx02Dq0gYiC5mNHfF5SD5tOYHRhVd66Vf+LoqW", + "aZYvpLeorISxOqG4fPBVYc7HQw5HrtHS2NbriAzWlO5xEBAuPBdMX0M44TXss0KU9Sghu1bXRTfhpqkX", + "WBZOSMrKu+A2R2+WAQhmYuoDHg6uTUlLRTeHu670uAODy/UnpjNL1Ts/nxsBHXhKBPPqNPf0lptT2afv", + "RvzTz3Q7+ZDEwzZMIkoE7PAZCqL0Lv47SVnRFBSn5aQP46sStsJW16W0LfopG8/QyJBw0OW0O17a7TTI", + "WTgJFj4TQ4nLTYi3v79bWskI+xe+WGkZCT/LWhamt4VtOfwJ++uk7ONFn9Bm0pQ7JhQcKwl0gma7kKDh", + "0gedtPHSxqhctEZ4rDVJVSX/Jsu9T0rXr+jRbmWl1Y0oUoXoS7USuSEVzKkW41eh74f5bFOXVtxynNeh", + "L5mw09ehWPmrUBZcFwyKp99889Wfu6kQPiN2NdykpHuPX5bXMnIr8q4c26zuCCYWUHm2UkOWNWps06vW", + "9tAY11KJW4+3kSEg46HvQdHqHUQWe8YjUldObC+taH+au9/W3Kxb1hmVLcYy0px5ftX3+sP4osjQ98Dh", + "556wszs5ZvSOxxjjaA/J53A2YvZI9HAsS3wdcZLBCjd+iaR3dfQSgi5xr6sSnGzX8sDRNDoBNXTlhznf", + "iWGV/3i89K5jAywdqJwkQnlZnTDZSlyoIGihuoV38GB/3sVwpfLirTUYB1Ha+2atk5lGpvJvtpkPE3nV", + "T8Ltu96e9jKT4L6NSrjV9SdKYDNFA59HFoe0I9a0yDyWi4EdE5jXJKPqJ6Eal56jrLBTpD+ab7X7fj4+", + "o4kHp+/lNuaeZqrgoHYZhY7GGbrYSyL/1qsR5VhJ+Wp8yj0y/voCAN39untI/geMEFgqym4gLc9tm1p8", + "9syPNPNFfmdraytzcX6+3W7PwjRnudqcrzDKKbOqztfnYSBMI9lJnea7+OpX7tot91bkhj178xKFZGFL", + "wIAJRF2UUPdi9vTsCaVeBMkrMbuYfX325OwrOiJrpItzSnPs/ruiMAdHNSgJvywwBP0a4kTJWDsbUyFj", + "96dPnoRt8M/EyDx5/k9DDO04i2k8DW5ydyMeoT3tcVSQP1FBWV5LtZXse60VMUhTbzZc7zEC2tZaGvb0", + "yRMmlj69MyX+4E5Mez+jiNzZr67f+c3T88hPrPfL+R/BRUMUHw58PudVZbLIgHywfbDCT7ZKRPEd3+eo", + "GXoFKEPb9HzRr+d/dE3UH45sdr7AShHHNoVjpz/3fv6hbX/x+Pf5H0G1/GHi07lPSzHVfWTfqNrM+R/k", + "Pk2qimiqdKcO2//D7jx0qNHV7pjPLt7/0eMzsOObqgRkMbMPvzbk3XAoT+Yf5s0vpVLXdRX/YoDrfI3d", + "d5nSYiWkI98tX61AZz0G8/8DAAD//zr1w2zG4AAA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/generated/common/types.go b/api/generated/common/types.go index 3a0e083ca..92b65acb9 100644 --- a/api/generated/common/types.go +++ b/api/generated/common/types.go @@ -1183,6 +1183,9 @@ type Exclude = []string // ExcludeCloseTo defines model for exclude-close-to. type ExcludeCloseTo = bool +// GroupId defines model for group-id. +type GroupId = string + // HeaderOnly defines model for header-only. type HeaderOnly = bool diff --git a/api/generated/v2/routes.go b/api/generated/v2/routes.go index 6b9f38d0d..f1d6ccc15 100644 --- a/api/generated/v2/routes.go +++ b/api/generated/v2/routes.go @@ -8,1155 +8,21 @@ import ( "compress/gzip" "encoding/base64" "fmt" - "net/http" "net/url" "path" "strings" - "github.com/algorand/oapi-codegen/pkg/runtime" "github.com/getkin/kin-openapi/openapi3" "github.com/labstack/echo/v4" ) // ServerInterface represents all server handlers. type ServerInterface interface { - - // (GET /v2/accounts) - SearchForAccounts(ctx echo.Context, params SearchForAccountsParams) error - - // (GET /v2/accounts/{account-id}) - LookupAccountByID(ctx echo.Context, accountId string, params LookupAccountByIDParams) error - - // (GET /v2/accounts/{account-id}/apps-local-state) - LookupAccountAppLocalStates(ctx echo.Context, accountId string, params LookupAccountAppLocalStatesParams) error - - // (GET /v2/accounts/{account-id}/assets) - LookupAccountAssets(ctx echo.Context, accountId string, params LookupAccountAssetsParams) error - - // (GET /v2/accounts/{account-id}/created-applications) - LookupAccountCreatedApplications(ctx echo.Context, accountId string, params LookupAccountCreatedApplicationsParams) error - - // (GET /v2/accounts/{account-id}/created-assets) - LookupAccountCreatedAssets(ctx echo.Context, accountId string, params LookupAccountCreatedAssetsParams) error - - // (GET /v2/accounts/{account-id}/transactions) - LookupAccountTransactions(ctx echo.Context, accountId string, params LookupAccountTransactionsParams) error - - // (GET /v2/applications) - SearchForApplications(ctx echo.Context, params SearchForApplicationsParams) error - - // (GET /v2/applications/{application-id}) - LookupApplicationByID(ctx echo.Context, applicationId uint64, params LookupApplicationByIDParams) error - // Get box information for a given application. - // (GET /v2/applications/{application-id}/box) - LookupApplicationBoxByIDAndName(ctx echo.Context, applicationId uint64, params LookupApplicationBoxByIDAndNameParams) error - // Get box names for a given application. - // (GET /v2/applications/{application-id}/boxes) - SearchForApplicationBoxes(ctx echo.Context, applicationId uint64, params SearchForApplicationBoxesParams) error - - // (GET /v2/applications/{application-id}/logs) - LookupApplicationLogsByID(ctx echo.Context, applicationId uint64, params LookupApplicationLogsByIDParams) error - - // (GET /v2/assets) - SearchForAssets(ctx echo.Context, params SearchForAssetsParams) error - - // (GET /v2/assets/{asset-id}) - LookupAssetByID(ctx echo.Context, assetId uint64, params LookupAssetByIDParams) error - - // (GET /v2/assets/{asset-id}/balances) - LookupAssetBalances(ctx echo.Context, assetId uint64, params LookupAssetBalancesParams) error - - // (GET /v2/assets/{asset-id}/transactions) - LookupAssetTransactions(ctx echo.Context, assetId uint64, params LookupAssetTransactionsParams) error - - // (GET /v2/blocks/{round-number}) - LookupBlock(ctx echo.Context, roundNumber uint64, params LookupBlockParams) error - - // (GET /v2/transactions) - SearchForTransactions(ctx echo.Context, params SearchForTransactionsParams) error - - // (GET /v2/transactions/{txid}) - LookupTransaction(ctx echo.Context, txid string) error -} - -// ServerInterfaceWrapper converts echo contexts to parameters. -type ServerInterfaceWrapper struct { - Handler ServerInterface -} - -// SearchForAccounts converts echo context to params. -func (w *ServerInterfaceWrapper) SearchForAccounts(ctx echo.Context) error { - var err error - - // Parameter object where we will unmarshal all parameters from the context - var params SearchForAccountsParams - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "currency-greater-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "exclude" ------------- - - err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), ¶ms.Exclude) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err)) - } - - // ------------- Optional query parameter "currency-less-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) - } - - // ------------- Optional query parameter "auth-addr" ------------- - - err = runtime.BindQueryParameter("form", true, false, "auth-addr", ctx.QueryParams(), ¶ms.AuthAddr) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter auth-addr: %s", err)) - } - - // ------------- Optional query parameter "round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) - } - - // ------------- Optional query parameter "application-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.SearchForAccounts(ctx, params) - return err -} - -// LookupAccountByID converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountByID(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountByIDParams - // ------------- Optional query parameter "round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "exclude" ------------- - - err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), ¶ms.Exclude) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountByID(ctx, accountId, params) - return err -} - -// LookupAccountAppLocalStates converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountAppLocalStates(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountAppLocalStatesParams - // ------------- Optional query parameter "application-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountAppLocalStates(ctx, accountId, params) - return err -} - -// LookupAccountAssets converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountAssets(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountAssetsParams - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountAssets(ctx, accountId, params) - return err -} - -// LookupAccountCreatedApplications converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountCreatedApplications(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountCreatedApplicationsParams - // ------------- Optional query parameter "application-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountCreatedApplications(ctx, accountId, params) - return err -} - -// LookupAccountCreatedAssets converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountCreatedAssets(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountCreatedAssetsParams - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountCreatedAssets(ctx, accountId, params) - return err -} - -// LookupAccountTransactions converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAccountTransactions(ctx echo.Context) error { - var err error - // ------------- Path parameter "account-id" ------------- - var accountId string - - err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAccountTransactionsParams - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "note-prefix" ------------- - - err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) - } - - // ------------- Optional query parameter "tx-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) - } - - // ------------- Optional query parameter "sig-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) - } - - // ------------- Optional query parameter "txid" ------------- - - err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) - } - - // ------------- Optional query parameter "round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) - } - - // ------------- Optional query parameter "min-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) - } - - // ------------- Optional query parameter "max-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) - } - - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // ------------- Optional query parameter "before-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) - } - - // ------------- Optional query parameter "after-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) - } - - // ------------- Optional query parameter "currency-greater-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) - } - - // ------------- Optional query parameter "currency-less-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) - } - - // ------------- Optional query parameter "rekey-to" ------------- - - err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAccountTransactions(ctx, accountId, params) - return err -} - -// SearchForApplications converts echo context to params. -func (w *ServerInterfaceWrapper) SearchForApplications(ctx echo.Context) error { - var err error - - // Parameter object where we will unmarshal all parameters from the context - var params SearchForApplicationsParams - // ------------- Optional query parameter "application-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // ------------- Optional query parameter "creator" ------------- - - err = runtime.BindQueryParameter("form", true, false, "creator", ctx.QueryParams(), ¶ms.Creator) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter creator: %s", err)) - } - - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.SearchForApplications(ctx, params) - return err -} - -// LookupApplicationByID converts echo context to params. -func (w *ServerInterfaceWrapper) LookupApplicationByID(ctx echo.Context) error { - var err error - // ------------- Path parameter "application-id" ------------- - var applicationId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupApplicationByIDParams - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupApplicationByID(ctx, applicationId, params) - return err -} - -// LookupApplicationBoxByIDAndName converts echo context to params. -func (w *ServerInterfaceWrapper) LookupApplicationBoxByIDAndName(ctx echo.Context) error { - var err error - // ------------- Path parameter "application-id" ------------- - var applicationId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupApplicationBoxByIDAndNameParams - // ------------- Required query parameter "name" ------------- - - err = runtime.BindQueryParameter("form", true, true, "name", ctx.QueryParams(), ¶ms.Name) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupApplicationBoxByIDAndName(ctx, applicationId, params) - return err -} - -// SearchForApplicationBoxes converts echo context to params. -func (w *ServerInterfaceWrapper) SearchForApplicationBoxes(ctx echo.Context) error { - var err error - // ------------- Path parameter "application-id" ------------- - var applicationId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params SearchForApplicationBoxesParams - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.SearchForApplicationBoxes(ctx, applicationId, params) - return err -} - -// LookupApplicationLogsByID converts echo context to params. -func (w *ServerInterfaceWrapper) LookupApplicationLogsByID(ctx echo.Context) error { - var err error - // ------------- Path parameter "application-id" ------------- - var applicationId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupApplicationLogsByIDParams - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "txid" ------------- - - err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) - } - - // ------------- Optional query parameter "min-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) - } - - // ------------- Optional query parameter "max-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) - } - - // ------------- Optional query parameter "sender-address" ------------- - - err = runtime.BindQueryParameter("form", true, false, "sender-address", ctx.QueryParams(), ¶ms.SenderAddress) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sender-address: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupApplicationLogsByID(ctx, applicationId, params) - return err -} - -// SearchForAssets converts echo context to params. -func (w *ServerInterfaceWrapper) SearchForAssets(ctx echo.Context) error { - var err error - - // Parameter object where we will unmarshal all parameters from the context - var params SearchForAssetsParams - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "creator" ------------- - - err = runtime.BindQueryParameter("form", true, false, "creator", ctx.QueryParams(), ¶ms.Creator) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter creator: %s", err)) - } - - // ------------- Optional query parameter "name" ------------- - - err = runtime.BindQueryParameter("form", true, false, "name", ctx.QueryParams(), ¶ms.Name) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err)) - } - - // ------------- Optional query parameter "unit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "unit", ctx.QueryParams(), ¶ms.Unit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter unit: %s", err)) - } - - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.SearchForAssets(ctx, params) - return err -} - -// LookupAssetByID converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAssetByID(ctx echo.Context) error { - var err error - // ------------- Path parameter "asset-id" ------------- - var assetId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAssetByIDParams - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAssetByID(ctx, assetId, params) - return err -} - -// LookupAssetBalances converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAssetBalances(ctx echo.Context) error { - var err error - // ------------- Path parameter "asset-id" ------------- - var assetId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAssetBalancesParams - // ------------- Optional query parameter "include-all" ------------- - - err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) - } - - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "currency-greater-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) - } - - // ------------- Optional query parameter "currency-less-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAssetBalances(ctx, assetId, params) - return err -} - -// LookupAssetTransactions converts echo context to params. -func (w *ServerInterfaceWrapper) LookupAssetTransactions(ctx echo.Context) error { - var err error - // ------------- Path parameter "asset-id" ------------- - var assetId uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupAssetTransactionsParams - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "note-prefix" ------------- - - err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) - } - - // ------------- Optional query parameter "tx-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) - } - - // ------------- Optional query parameter "sig-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) - } - - // ------------- Optional query parameter "txid" ------------- - - err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) - } - - // ------------- Optional query parameter "round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) - } - - // ------------- Optional query parameter "min-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) - } - - // ------------- Optional query parameter "max-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) - } - - // ------------- Optional query parameter "before-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) - } - - // ------------- Optional query parameter "after-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) - } - - // ------------- Optional query parameter "currency-greater-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) - } - - // ------------- Optional query parameter "currency-less-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) - } - - // ------------- Optional query parameter "address" ------------- - - err = runtime.BindQueryParameter("form", true, false, "address", ctx.QueryParams(), ¶ms.Address) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address: %s", err)) - } - - // ------------- Optional query parameter "address-role" ------------- - - err = runtime.BindQueryParameter("form", true, false, "address-role", ctx.QueryParams(), ¶ms.AddressRole) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address-role: %s", err)) - } - - // ------------- Optional query parameter "exclude-close-to" ------------- - - err = runtime.BindQueryParameter("form", true, false, "exclude-close-to", ctx.QueryParams(), ¶ms.ExcludeCloseTo) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude-close-to: %s", err)) - } - - // ------------- Optional query parameter "rekey-to" ------------- - - err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupAssetTransactions(ctx, assetId, params) - return err -} - -// LookupBlock converts echo context to params. -func (w *ServerInterfaceWrapper) LookupBlock(ctx echo.Context) error { - var err error - // ------------- Path parameter "round-number" ------------- - var roundNumber uint64 - - err = runtime.BindStyledParameterWithLocation("simple", false, "round-number", runtime.ParamLocationPath, ctx.Param("round-number"), &roundNumber) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round-number: %s", err)) - } - - // Parameter object where we will unmarshal all parameters from the context - var params LookupBlockParams - // ------------- Optional query parameter "header-only" ------------- - - err = runtime.BindQueryParameter("form", true, false, "header-only", ctx.QueryParams(), ¶ms.HeaderOnly) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter header-only: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupBlock(ctx, roundNumber, params) - return err -} - -// SearchForTransactions converts echo context to params. -func (w *ServerInterfaceWrapper) SearchForTransactions(ctx echo.Context) error { - var err error - - // Parameter object where we will unmarshal all parameters from the context - var params SearchForTransactionsParams - // ------------- Optional query parameter "limit" ------------- - - err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) - } - - // ------------- Optional query parameter "next" ------------- - - err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) - } - - // ------------- Optional query parameter "note-prefix" ------------- - - err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) - } - - // ------------- Optional query parameter "tx-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) - } - - // ------------- Optional query parameter "sig-type" ------------- - - err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) - } - - // ------------- Optional query parameter "txid" ------------- - - err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) - } - - // ------------- Optional query parameter "round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) - } - - // ------------- Optional query parameter "min-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) - } - - // ------------- Optional query parameter "max-round" ------------- - - err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) - } - - // ------------- Optional query parameter "asset-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) - } - - // ------------- Optional query parameter "before-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) - } - - // ------------- Optional query parameter "after-time" ------------- - - err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) - } - - // ------------- Optional query parameter "currency-greater-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) - } - - // ------------- Optional query parameter "currency-less-than" ------------- - - err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) - } - - // ------------- Optional query parameter "address" ------------- - - err = runtime.BindQueryParameter("form", true, false, "address", ctx.QueryParams(), ¶ms.Address) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address: %s", err)) - } - - // ------------- Optional query parameter "address-role" ------------- - - err = runtime.BindQueryParameter("form", true, false, "address-role", ctx.QueryParams(), ¶ms.AddressRole) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address-role: %s", err)) - } - - // ------------- Optional query parameter "exclude-close-to" ------------- - - err = runtime.BindQueryParameter("form", true, false, "exclude-close-to", ctx.QueryParams(), ¶ms.ExcludeCloseTo) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude-close-to: %s", err)) - } - - // ------------- Optional query parameter "rekey-to" ------------- - - err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) - } - - // ------------- Optional query parameter "application-id" ------------- - - err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.SearchForTransactions(ctx, params) - return err } -// LookupTransaction converts echo context to params. -func (w *ServerInterfaceWrapper) LookupTransaction(ctx echo.Context) error { - var err error - // ------------- Path parameter "txid" ------------- - var txid string - - err = runtime.BindStyledParameterWithLocation("simple", false, "txid", runtime.ParamLocationPath, ctx.Param("txid"), &txid) - if err != nil { - return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) - } - - // Invoke the callback with all the unmarshalled arguments - err = w.Handler.LookupTransaction(ctx, txid) - return err +// ServerInterfaceWrapper converts echo contexts to parameters. +type ServerInterfaceWrapper struct { + Handler ServerInterface } // This is a simple interface which specifies echo.Route addition functions which @@ -1183,258 +49,14 @@ func RegisterHandlers(router EchoRouter, si ServerInterface, m ...echo.Middlewar // can be served under a prefix. func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string, m ...echo.MiddlewareFunc) { - wrapper := ServerInterfaceWrapper{ - Handler: si, - } - - router.GET(baseURL+"/v2/accounts", wrapper.SearchForAccounts, m...) - router.GET(baseURL+"/v2/accounts/:account-id", wrapper.LookupAccountByID, m...) - router.GET(baseURL+"/v2/accounts/:account-id/apps-local-state", wrapper.LookupAccountAppLocalStates, m...) - router.GET(baseURL+"/v2/accounts/:account-id/assets", wrapper.LookupAccountAssets, m...) - router.GET(baseURL+"/v2/accounts/:account-id/created-applications", wrapper.LookupAccountCreatedApplications, m...) - router.GET(baseURL+"/v2/accounts/:account-id/created-assets", wrapper.LookupAccountCreatedAssets, m...) - router.GET(baseURL+"/v2/accounts/:account-id/transactions", wrapper.LookupAccountTransactions, m...) - router.GET(baseURL+"/v2/applications", wrapper.SearchForApplications, m...) - router.GET(baseURL+"/v2/applications/:application-id", wrapper.LookupApplicationByID, m...) - router.GET(baseURL+"/v2/applications/:application-id/box", wrapper.LookupApplicationBoxByIDAndName, m...) - router.GET(baseURL+"/v2/applications/:application-id/boxes", wrapper.SearchForApplicationBoxes, m...) - router.GET(baseURL+"/v2/applications/:application-id/logs", wrapper.LookupApplicationLogsByID, m...) - router.GET(baseURL+"/v2/assets", wrapper.SearchForAssets, m...) - router.GET(baseURL+"/v2/assets/:asset-id", wrapper.LookupAssetByID, m...) - router.GET(baseURL+"/v2/assets/:asset-id/balances", wrapper.LookupAssetBalances, m...) - router.GET(baseURL+"/v2/assets/:asset-id/transactions", wrapper.LookupAssetTransactions, m...) - router.GET(baseURL+"/v2/blocks/:round-number", wrapper.LookupBlock, m...) - router.GET(baseURL+"/v2/transactions", wrapper.SearchForTransactions, m...) - router.GET(baseURL+"/v2/transactions/:txid", wrapper.LookupTransaction, m...) - } // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9e5PbNrI4+lVQuqcqdq444ziPOjtVqVN+rG9ca2dTtpM953hy70IkJGGHAhgAHEnJ", - "9Xf/FboBECRBiZrRjO2N/rJHxKMBNBr97j8muVxVUjBh9OTij0lFFV0xwxT8RfNc1sJkvLB/FUznileG", - "SzG58N+INoqLxWQ64fbXiprlZDoRdMWaNrb/dKLYbzVXrJhcGFWz6UTnS7aidmCzrWxrN9KHD9MJLQrF", - "tO7P+ndRbgkXeVkXjBhFhaa5/aTJmpslMUuuietMuCBSMCLnxCxbjcmcs7LQZx7o32qmthHUbvJhEKeT", - "TUbLhVRUFNlcqhU1k4vJE9fvw97PboZMyZL11/hMrmZcML8iFhYUDocYSQo2h0ZLaoiFzq7TNzSSaEZV", - "viRzqfYsE4GI18pEvZpcvJ9oJgqm4ORyxq/hv3PF2O8sM1QtmJn8Ok2d3dwwlRm+SiztpTs5xXRdGk2g", - "Laxxwa+ZILbXGXlda0NmjFBB3rx4Rr7++uu/ENxGwwqHcIOramaP1xROoaCG+c9jDvXNi2cw/1u3wLGt", - "aFWVPKd23cnr86T5Tl4+H1pMe5AEQnJh2IIp3HitWfquPrFfdkzjO+6boDbLzKLN8MG6G69JLsWcL2rF", - "CouNtWZ4N3XFRMHFglyx7eARhmnu7gbO2FwqNhJLsfFR0TSe/6Pi6UxuMoSphzRkJjfEfrOUdCFpmVG1", - "gBWSL5jIpT3Hi2ta1uyLM/JCKsKF0VN31sw15MJcfPX4629cE0XXZLY1rNdu9t03F0++/941qxQXhs5K", - "5rax11wbdbFkZSldB0fM+uPaDxf//T//e3Z29sXQYcA/hz1Qea0UE/k2WyhGgeIsqejv4RuHQXop67Ig", - "S3oN6EJX8HS6vsT2xesBu3lGXvNcySflQmpCHeIVbE7r0hA/MalFaUm9Hc1dX8I1qZS85gUrpvbM1kue", - "L0lO3YZAO7LmZWmxttasGNqQ9Or2UIfQycJ1o/2ABX26m9Gsa89OsA3Qj/7y/7pxVLIouP2JloQbttJE", - "1/mSUO2gWsqyQKSPHgBSypyWpKCGEm2kJaxzqRzHg1R36vo3TBzJ4QALMtt2W4qiNfr+PnZ/2KYqpV3Z", - "nJaapffLrz7eJFhlzFvQspy4F8syWm7KLPxAq0pnsOJMG2pY3KaqbAshBUswIOEHqhTd2r+12VouC0jr", - "pDmdLC+lZpmRexgwz1PBhkUsU7xjB7Fj5N2SEZjcfkBWFDBbWCpdllti3AFYhCCe+ZoSPidbWZM1XJ2S", - "X0F/txqL0ytiDx+OrMUpWmo2hNy9zUig9kzKklEBqL1ktGAqk6Lc9vftB/hI7EcyL+nijPxjydxltm+/", - "hQ7BmRLFTK2ExbJS5lekkEwTIY3lGwzlosuy6wH4Y3j2gO6khsyi3jD/Uvoric0tqwJ7UwTWZkoKVjI4", - "n+b+wK/aKLmFc7NYPCWysvgqa9O/16Jww+Ln7jUHnB8UUOKV7Fl0yVfc9Jf7mm74ql4RUa9m9sTmgdcx", - "0h0N4KliJAd0m7WIVkUXTBNmWSGO0hXMYw/ZnqFiNF8OE1SEaQ8NXdFNpmQtihFChCFSxUyarljO55wV", - "JIwyBEszzT54uDgMnka0icDxgwyCE2bZA45gm8SxWspiv8ABRad6Rn52zx58NfKKifA6Ip1npFLsmsta", - "h05D3JKdejd3JKRhWaXYnG/6QL5122GJG7Zxb/PK8dOOBLCCODpgh0NCOQhTNOGhQsOMavbdN0Mcc/NV", - "sSu2Tb4XXQTA5QQtxdJ+wb67VxFm2HOpR+Ihsgcx/u3EvVF4B40yJBsJ9s5+dUQlrRFq9R/Bcsdzoz4i", - "u5VuCMfwL/PQVnRmujsxVPNFhiP2bglfvLNsxJyXwGL8y14Of7K1tu9S+2w906H5QlBTK3ZxKb60f5GM", - "vDVUFFQV9pcV/vS6Lg1/yxf2pxJ/eiUXPH/LF0Ob4mFN6oqg2wr/seOldUNmE5abmsJ/Ts1QUdvwim0V", - "s3PQfA7/bOaASHSufke2EZ5EU82HAEjpR15JeVVX8YbmLX3hbEtePh9CFhhyFz0E2qErKTQDrH2CjMQb", - "95v9yZI8JoCiR7zA+b+0BCGqGbtSsmLKcBbrZ+1//0Ox+eRi8n+dN/rcc+ymz92EkyCkmaGnDC8wNY6E", - "IelyRA2ZgVVVG3zaU9QhXOf3AbbunM2xyNm/WG5wg9pgPGCrymwfWoAd7Pp4u6VbAsnIfesKFXe4j/i4", - "Z/BI90f+WTvBr6ILLmDhU7K2bPaKXlmqQIU0S6aIPQumjX/mkfzhyx8Uy45XcLLC2SR1YxJnqm99qM2p", - "vbLs7ltgd49xxB2x8YCzToF0Ovlw8r2NPSYKLI509js17peX72lV8WJzeflrS+LiomCb9Hnc6WGXcpEV", - "1NCb4ejiue2aQNBPGYfa1oxjIdBxkeeAU7jfF/VY23Xky3YjGnuirIlbcXuiqjUzT2lJRX6U53Tmhhp9", - "wq+54ADED6jqOh2zP+awlcc4Yre7R7nIqHEffYVPh5u6w8GOceujPdaRjjrIe5YIYcpjbNLHQvwTxh8X", - "45+WMr+60VnuOioYdd/McnP8eeUmNetTuSFcoPbPcT5P5YZ9qiLPzMI2+lo8lZvnbkqpPm9pBBc+BoOf", - "Or8YDUZeEe+sXfJflZLqCKfrZcMOPNPJimlNFyxte4nX6BuOWZQHGA6E2SWAhvoHRkuzfLZkd3BRo7H3", - "XNd3jTL2CBt7pyQ70hvvW3+0qj3CXnvYA6lsNI3+1Hfv0yEXrS0fTxBbZ9olh+PPWB92yB+8/SE2MCRc", - "+pzPdvQc2ZOizq0RzYOX4lI8Z3MuwNp/cSksHTqfUc1zfV5rppyAebaQ5IK4IZ9TQy/FZNp9oIZsdeCC", - "5aCp6lnJc3LFtqlTQN+wxAjS0DJyYIjcxJzZuLFA9PEMR80sOsjaZM4rNVNsTVWRgFcHozWMjP5qu2ad", - "Ejc22tad16sbP437PZ+nvs/9TncwLtr+WvYgf5TGWaDpmiAikVozTf65otV7LsyvJLusHz36mpEnVdVo", - "vv/ZOJdZQMH2dVQ1OiwWzjBjG6NoBj4laUTR9Qpe2rIk0LbtuKbkQtGV80npusTt2GmcfNxLFS0LVvQW", - "e32YRmJE56jgd7JkZd+R7tCDiWTuG5/LHrl9h2v3uygCgS4oF9rTds0XwmK18+acMZLbt5wVZ+TlnABt", - "mrYCGFwohqN7gQBwjQ6Y5J1dF7hIkJwKcMysCnCF44JQse0aZTUzxlvC37Artn0XeVgcaKl37lh0z8NW", - "1Ha48Lg1p0rWVJOVBCt9zoQpt87DK4GCaWBqLgy6mrRcHXuARI6H9lZE+sMh183ImY1WFVmUcuZoR8DF", - "i4CMvs8wmfjJAqCPQCKS8nTbFXTf6vGaDbmsHr46O96tLtnONd0YueZcafATZNSRehpfhhvgmHNi7IPy", - "jyUDLkoqcOZr45H2lzeF3sFHCZwtmTD8mmWs5As+S8U55bT1YnpPV+cRGkbQhM8JN5o4FaoFgguiqFgw", - "y71YjkNqWmJURhKakmqTLRlVZsbogN8cHEzjKN5atu1P1pZkSVFywaZ2c9jG4jG3O6GYYGtW2NVw5doQ", - "+4bXA089AISAp45gFDy+O+wh7Fl6rhUXmdu6hCOo51/C7noG1bsFxlcJ4MLvKwYBDHJtz8VCIZ3vfc+z", - "vLYiaBq0iirDc16Ns7shID+1+thB9vFuSW5NzrtMWY9/SoKMjTO75v5MtUavbbsu/9j50VHuAajPCLiq", - "uU2aleDIHSKn8LypAg9zv1SMJBoCRw+xx37y9trjS7ek2l88iJPw78QojnWAmDXoa+lohL+x3MHtvCW7", - "pkM7PewbB77hXXc3YCH6cQ7eqRQjQb1PnHeE895v9l9L7+qytNSmFldCrq04c4h/23SCV74P8LUENgU/", - "e8RwIH6ho6OxcPx9Pgf6kREuCnuJQOigxoetyJxjdEBDky0tX9gfz+wAFrvsAKNHSKGtGxI4bClLHJj8", - "KOP7JxaHACkYh3eF+rHhgYn+ZmkpHNh04NjRn56LNMbl/pZbOaHFFQFgEGs0Y0ygWz7hYkosKbumpSVl", - "RiJrGgZJi1oPWlKSY9z1wyERLK0hwhUB53LQmpDXuclqYvbfA52WTXZAPJObDGL3+rBCCF5VZYGISVFu", - "MdKlK6fDCHY9MgcM8V7KV2yLQTYQ9gW3BDSyjn7MWCktpy97GNYc1B7gbwv4EaHZzeCnsFkD6iHn3aDd", - "jlCtvVMP8NdDaPcAcOgWAHT178G52ml49ipl2qxM/+FvXsNp48yOFDlNRoauYh/h21iUPMWB/e2r8YJP", - "609d7ieprGu1Ithk5vRQkSyUev0sOcql0EzoGqIhjcxledbT0mlWMhAjshZDll2xRJDXW9840tuRB3xu", - "5fOHkXSg2IJrw1pxiiH+oAmv2EJsX0WNYcoO//8++K+L90+y/6XZ74+yv/zf57/+8c2Hh1/2fnz84fvv", - "///2T19/+P7hf/3HZOBZZpbdlvP0mt5IGR4+aEygcWtp9w71tTQsA7kvu6Zlyrz3AoTCJKfVOkiCwbR8", - "QOcOE12xbVbwsk7j4o+BCup6BpSaC8KopYTU5Evgplsz2jY7ZgP5Z2BVr+jRFjUCnZU9+vbAnwled+jp", - "rkucQKbUsfcPZ3Afd5A14IyesxKNl8NZL/CiFbbh2S7DQe9iFH7sXdJiBMXwy4MjJdfS9gcdXgVY0oFv", - "4SaKu9W9FY3VAa1DyGzMgq5pUHLdua4nXl2s73GjpFUs7uMtltcffuzykumJxnk7wIEdorJEBqiHU3BX", - "3GB78Cmyi/QfVytGaCdw4AWJmEuMRxddJrODZyGseNxZeF7BRTnLOryEu3nZ4+EcSwhbuPYU+pG5kiu4", - "bH1eM1ZADuglWljXPC2dWV3apD6+WHoJAspeOzCj5d/Y9hfbFk7V9vYc5thb0qhpvJTnJY5bHc3tbF4p", - "zHcj7sV8DFoYQntIsIO2iZaF+sAbUMqFTsX4LZqQ2BgLZswKxWzD8to0as+Ocj3o/++XB+waEtLhi5HP", - "ASZ52s0pwP64sfac2E+BPN7lgdGqUvKalpmz5SapObTw1t575rXSF+rdX5+8+slBDAZERlUWZI30QqBR", - "I2N8smuxrIbcYwwGRZRXAHSfdGfM5bplAF5DSomO6GqZJ4dFuDGNET+6ps4gPPes9oHmXedkgEvc5WzQ", - "KHzQ16DtX0CvKS+9yt7DmH4qcEmNK8fBr0U8wK39FCK/kuyo9L93edM3YQ+hiWfYkTFihXlLNJEuM0Rz", - "WFYYBaMAoOWKbi22oFq2T3FEvQLNTqZLnjKLtdWVBFoNyLN2KPu07hrEftcjdGIdsKLBk9vn/fyHdmsm", - "nbNbLfhvNSO8YMLYTwruXOca2lvnE2jdWHpJWLAx0dY9yi8w4SGSi8vbc6vFhVFuIr9Y+SRhTcRTc+sJ", - "Z3cbOaZR4fb5OABitxATOxH1wH0eVJMei4KFgYqWGfkA78J4xh7bMOAZGN07wZ2d4wansj+dpheUXF6n", - "NH04SA6K00TdSvrR2VzJ31NetOv+tNGE2Cs96GjppXNPBqQY3kl3d4MjCgm2bgtSkHpvDVT3dQy2jSbH", - "anM4g5dsiO+ObTBtl9QBQg73DcJAqLq8/BUFS2/npQIv2DPI1doSedLXNHZQPsfxm2vqYO7rI+h6RvOr", - "xGIar8CWJdpI4juFlGnt0zkjkYNhaOuyj1VMrbhpk/tGoropZ4vTjuZpGxYWsClmXl3uxVLLxDC1WFNh", - "fA45R8Bcb83QpGN7raXSBrJZJldZsJyvaDlg3msIZMEXHJO+1ZpFKctcf1JJLgwiTcF1VdItuls2O/Jy", - "Th5NI+LlDqHg11zzWcmgxVfYYkY18CKNhsl3satiwiw1NH88ovmyFoVihVm6bHpakiB0gIImeH7MmFkz", - "JsgjaPfVX8gD8HLR/Jo9tJvneMrJxVd/AQsj/vEoTcsh7+ggbfUkPY214NODXe2j6AZL01rMs33QncEu", - "Y24MtHQEf/+NWVFBF6lsXztgwT6NXb+zD6LAlJnAMhFu0vMyQy3VyZZUL1PpiXO5WnGzcv4OWq4stjQJ", - "sXAuPwra9JFcB3D8R/BArkhauXa/Gp90LuYf6Yq1N3FKqCa6tqA2SitH3M6ISwVXYC7ORpsIW4IpndEj", - "DXW+8yjhcm3m2X+SfEkVzS0pOxuCMpt9900f0qeQL49AfmhW4FzjAb/37VZMM3U97qJ5Nsn1IQ+EFNnK", - "kofioaPU7Ts36M6UJstdh5PdQ47lkewo2W6sohGVvRV+iR0D3hLjwjIOQruDV3bvCFirBDb8/OaV4wdW", - "UrG2bnXmY4panIViRnF2DaEX6bOxY97yCFQ5avNvA/3HtaF75jBioPyNTbHqGGje3w7nvx6WPST0Snl1", - "xVjFxeIc/beBmcZRu2z0TIp6QGNZScs7cVoSaEQqurW7HFjQHb7hc8Z0lsuyZHlSRu1EX9nmpKIcr02c", - "YdM7Pu6Ya8EE01wPPOeXl+8XSyuh2M/2JY60LBgQgD53+v6vqAd8IMJ+wYSF++XzfVD3Bm67VWCo014d", - "Tssf7GfXxw7m0vdmMO/wLtt2Ft6ffLpfhNO2v/+tdTEMagCx3ddAv7vYNVb57wfK8GoMhaOampY+thOw", - "e86UK2DSAgd0MFBigjGiubja65u/N13FG9d22Kn+8vK9EoU9uWcufA59pNp2bDzMNQW7BBNFA32+pHzA", - "J1Uzlp7QfrAzvpXKcHTaYewjO/AZRfOrpALynf2igxMfetpH7nx6dCAXWCN+sn3e+dlSxli+YtrQVZXc", - "O6PtzuFbAO+K3b7QxRJMzXIpCm0xKGeEVVIv92UU0OmpNgImK7lGXiemzLlUmH0WeFcjO9HeY7dkZ1x7", - "G8ZMSWmGALVwthISSGkIrc3SPmE+joBBrYDuSjD6DeRWEQU9kdeWy/B5e2lZbqeEmy9wHOU8OylZMXVV", - "MmIUY2S9lJqRktFr1hQVgdG+0OTdhhcaSoaUbMNzuVC0WvKcSFUwhdVmbHOQpbGTm+/RGXFRvS4O4t1G", - "wPJCcYN4nbhMH70SLFrxiqfIwnV/hloPmpXXTJ+Rd2uJQOgmt4G23G+rx6w2GDNY8PmcAfWA5YAoDv2a", - "DxFMUB4FQg3CsG5N908DehiW6SV9/O13Q4j2+NvvUrj29ocnj7/9znLCVBBab3jJqdrGzWyrKZnVvDQu", - "0TYl1yw3UsUaBy60YbTo4RZqo9wswMvMa5E7N7TQJS5i8/aHJ99+9fj/e/ztd059Fc3io6BdgB0T11xJ", - "YT95hWHAEDdlmI1tuDYfgVsyG5GBvJx61e3R5HAsG/EMGxEXeNE253ZI2Ar1U/7il6xYMDVtHmJLV5uc", - "I1a4kyrigOcMQ8Tsu8iFUbKoc4aZLt626EYEFu+BFMonRO42cNd9FaEGTq9JDTwLIS9BAn6EApmQ7RXC", - "HWPXTGFMTzPQA3wcIri0oQr8lMBtyS2VFQ/TT3tdLRQt2DgvBHisfsYeIXGDH+FaHjbAL7Z9V8BqyQAt", - "zjrNwEaBHJZHid/c1Juzg0oMym9vhiIoX2BlHsVKDHWDyijQdtqTzuaMZZYRTGK8lZogAVees8pielyJ", - "kjH71uBNh7sMFfI80xaCoDEIL63BApiynJZ5XaIosYOFXOe0BEtQg9glmxtpcS+utNWYAridawYe4lhS", - "BOdT9g2LekDaqGumtq4Fal58BQ97b1THdafPKmclu2ZlEnBGFfAOP8g1WVGxDWdhp2jAmEaRcQFyZILB", - "QwRP+2enFIrAx3vmEHI3kPYoBja3iM+5YorLgueEi38xd9Fj0QEwBksBSWG4qKH4k2IN3PjUEwjR7Ybh", - "9jFAJV2KLVzUMAtYE8Uh2Lp12kUkKLSDIbShVwzB9sHEjrsZe6aKaV7UacjmiuZtyA5DRnd531DDzlU4", - "Wn0kvOwQr3DJd126Li530KZzWv1dGqRTLbo8hljREPFFHA1POIu7DFS+5YDGQBoJj3aUuyWMfc2Ubrsh", - "R2YCttkztm3RGh/zcvnUBofPknl/ND043xbJcYNznn/GwHvo79IqpHZwIGlZAECvucmXWSpwxAGALSwM", - "b7oifH9K5C7gFrL5nOVmDAwQtYMVsQahwM8WiueMFhAx3kRdYbxVF5QHP0pih9YRyyM0B0Gi4XhglIcH", - "JDQPGLIP+X+RI3HfBdyDJ8SIa+B5HHf2yS1zbRzyvAxR75RsmYZdCd7l0R2BzCRpE6+ftGAl3e6aEhq0", - "Jw08rzdu45sDCTzsg4Le7INByH5qd892TW6bdBccrmf/VsSldnonKRNObj6XZgihclkJEz6bSRuWRWa6", - "AjT25WqnZNYySNy/UfE4aTHScY0++KS3DfDF7wP80d2Ij2xd8WV23TuJK/k1jShRUtkkyhThexQSjXEG", - "sH6ffI+6KrIjsaljyfIY9QnsW2qf/npNy4FAyzesUkyDnoCSd3998so5xQyFW+bpSMfLy/fUWJyCfmQw", - "2dSH6WQgM8Tl5fsZUEzM+xBOo29dTPpQW0LEbXf7udf7Zi55Q0lUow31vvh9gP7mA8BIRblz9GpiTfs7", - "64KO+9HdY4LImgPuLsJF9Q5eoR+oXr6guZFq28/gakXrgdQ6l5fv7XkfssVffZcm9xaE9CTvovw9bRVZ", - "8P8D3zvPD8l5L48PgUQ+S+o0Z/5PK+lHSXvC98l00tMDNGcR5yFO+Bkt4TPmNiS+klv/pAfTNRezLISN", - "pCo6Ticu3XKcY3ZvKBjX2YovFLA86VGH00RHT1TihUFWO1EW2bE1w7x4B0lbC+9A3IAXvQhu5hRCvxQF", - "2zDVWGZeN6vrWMpRfQSFgXXWKFPTtAmR/X75A4zDt1Now4od2pr5gVcRPX5Ky6aNGr+82fgiAzZZZGvG", - "F8v0xv50o6EtG73/0K7v/9BSBO41aP2f2AsJGDlAaOcNGd6ZDD2i2OAbYAbs92aJy/9UQlIVszJMNQCu", - "KQ5EhP8c2OxuZaEEodZ8VZXo/OlISS/31UGJJpoAk7uPVzp20Medh2+wG3skHj9q46aw7E9JtTtW4+/i", - "mVxVJRtmnisqkH2ec+Hk9vWSmriYurcByTyvVWPE7UZj/EJLjlV+NWQxFFJWkLawMlzY/0ACB1kb/D+j", - "yv4HnYra/0OsivgkO9QEzgWSX/mBfCTnZDrBzhOP2UkuKumY1NuUdjorf57ghA22NMFYAQEJTTbpc5ob", - "tH86Z03BzFqqq4QYM9OgT2r5VcVlX/vUlCpTVxRFFBo8KFwK15AVLoDmINO1Ru+alv/EXlrJNpXFtcMB", - "LNTqeiSEYfOkuGbK2T6kyymJVg5MU9tL2EQceIesKUWqb5gAaJQbSl9CS2xzwySiajDt2wRqLRXLyZGv", - "UN9lM1fbyshzaANNzrVRdW40em02c/aw0m40Oi/tr5/XZSksJyA1R3umkZli14wOqenBVYv9VjN7yGCq", - "s41JGCB1sGOJdnePcez01gIgsSsMBk2hg1259ckyqd3zFa3e4yy/koy8QYhDKQXwyFvpRXW45xYOlQJd", - "09Jkg1KO4y/JW1qamI2wADk/j+AhM5y4FjnY5Oj5xxA5LEw3R0G7YFbsYvfXN2D3B2kHzBseCuTA2lfq", - "mimMhR6NDr/4Hh+mk3tdx5twY/tUIVrfuFXEmxKRhrSKxX/116lJlUxFQaL5NYG7kfAVhKvLhFHbm6QZ", - "4otMl/KA5b3li7e2w54t9c16e1rKNVOZnXfHEZfe1IjxNtiylUo61HLB8dBTghXELkbfbCNw4IN2wnXZ", - "vxfN2B2nFFrmUmSt2e+X6iC9zAC7spDlYM/u0VV79yovWx9KtYBIbLlYpDM/WkJ/xbafhi4h4XHcO08w", - "8Q4rc0DQ+DE4NERGprUzIqORsM3o7KkiYcU14DRduZwd98q071XjX7TiuZIUnDGalNOsx8E6YQ98GcNu", - "7HIwSSuXMTE3dn63rVhwyu2X2lnRystbIIdbJvjsLpVW5E1wR+57lOZSGMqhoE6SuUdnXFZWQKga3fjZ", - "J4W+v0Qvc8fXZPf+5CtAoMhwFftv2//3t8woxu7fw/WKbbOSz5nhAwbpcm5X8je2Jb7Z2dF4iqEcSS2D", - "H2geSowJaPI+EanwywK+xOmlCNJRCJLW/i9NCmaYWllUXMo1WdX5Enh3umA+wRIYbMCzvDNRa3SfkaKd", - "HszFB+qK5jgQhv2XVC2YIi4SP9Ql8QagFeVwTxpv4G58LjiK0ZQxbl/ap9eYCiCiXWA6jXJAJbJLeTCu", - "2PYcLYPw+w0IyXAqqQHAIK/UHYJ0q/RUcU6zPfh61TKqYrGvVvK3AP4RjasWPqdCONC42s/WNnZ5sA64", - "DrVm/XWOj8aJ9zYh4jZrG+sZ0N/cAYP+Pjv+QMkWZ+4FOg59CcBH/vnVP4lic6ZAb/XllzD8l19Onb/C", - "Px+3P1ts+/LLtFNT8uYcz28gVAKwY7jpktjRLgDbsaHiI68xnBYd1+yDJgW4bJZlJ+RJFASSDQB7QiEC", - "hJWyYsnWUKwsfkEhAZxii7qkGOrDhWCq1WlMph8U/81GOFUX/PluI1JtY3YSWkfbkSoQGlVhvlnl3E45", - "OcyzlENGo5uO2OREakbE7Cq3GfEFpnQJI/oI09uM+c6NsaeE4+Xle70QoJbzyjjuswQAA4wn3MamkDnA", - "l3n0mYpCOBv7raalC9cTEBz3DtL25FdMYAVHS+Vc9V3ChK6VUwlaWGE8C4obRsaPuW6a3LSW43BBsMvL", - "9ypH7a/zaHfJICDzFHa1bEZhD0fuLqpi21sRcygZneVsqZ3LNfTxxeAruk/0AjRWq2EbfidbdBxZAhkX", - "ff+B4Zv6JU0p9HQuwiapZOdlxvz3D14+f0h4txh6nPUxErT2LzsuoTIOIsww0oOlm3vyECjmjA2F83QC", - "C8mcDaiCd5bvsGOBVIh1PKBV1wV7L5Qjsyr8QDVU6XDNm0j6TzGVQgtI8vJ5ks9oZcc9uCTEdLJQsk5H", - "bi8UmIa6vqBWCAAGCwV4dC47f/ztd6TgC6bNGfkHJNfDx7dfF619moQ39dZapTwJABYStCIb5IIRozmX", - "7kB7wcHcBSXCMPd/wjfJTz6dAF+SmU0qwP1lj2chlYvghNyiEb1pub0fI6ydC6MoEt9MzufJfLt/h98b", - "twjlabJi/VMfQZWv2Faxm/Iuf4POocToMOUpgfJArZ2bEZ6S0YHIgXKTuD5fP86aG3RGXtnehIm5VFaq", - "XtVg6WMbSMznDG4xlwrp60xTHhoy14nfmZKgNBBEOsN2946FzYYoS5oDP69dFLGFISTWDYrJB2+Bm5ki", - "kA9RJu1fNVILw5H9sdv4S7SLlX14LND/WPIygQWVtN91DMeUCEkkOAfFLTGtQZN1EWF2YeEtRLrfax6n", - "Ey/Spn6LCRAP+SqqrdFoJPIlFU3F9v0lGfo4Oa4mc68oUeKapytG2AUscAGLo8D5cR31hBwID7UfgA1R", - "DDMkBu3ZPScDotsVE+aGlO8n7I2+CVDPVu2WANSABOB776sDfMW2mZHpsRkalpAzD6IW6EmR2kZrnA7I", - "PSHGztfAb3hXvEGWRZjXYNCNTJdeT+pEuuBPdsW2jbdLXCsQxaYbSFn4LKa14O/4ijVyCTJyKRaIj3oS", - "UbxMy7WYEwlJ9hc7lhOG2Y0VegArsO9unBht543QNjL09vIc3eAWRG5IkItjR5jHtmLtwD5wTAyKulaS", - "C9AZnJHnIUkM+CFirH2TOQb1WV1vRcyIErIkc+X1XlR5fTU4NIKzG9yaBCFwDZA3sm36XJJrQvM5NBhS", - "BPlmmzlTTbuUMsa3nKvfm4Z9PZBvVlXgWTCg0XKttKnAODR00o1TZkW3E88MTqYTuyz7jwXb/jtXv9t/", - "qqqEKqfVvO+Tmb7ADicymCcR4j5pS60tRjLcxAa19mhAd9bRc4G7c6zBG17VQ9WTsQId05E3PzyjZflu", - "I5wfYD/sbYfnJa0w9O2V87gMFNqScee+67VWjjrElhia55bFK5qUDxGcX2jSrZuCiSD6lVN2eGPupdBd", - "FiDGTaoWg+sGhVWfDeU5oWpRY/qhe1jfnhUMSDa04oVLyNgvZOdYNiQLtWIFkcql8uJzl6dtqJLD/jJV", - "uHuV4xl53rCGTRaKAUyfWuGHVS7ZuhRZHjzL7TtpJUwjySV6ZF9OzshLzBmjGC2QwCpuWKqOUmv9kPx2", - "zaCss8foLJxuVAXvzN6iVs0tDZitGPhPJEqkfZb1uODEdD1wYkNUCbmq9iF9hBN61i8mBsUChDSf0TmN", - "qsx1efmeVXCx2mUv4jiKqgrFukpm9/23GgLgLMGGYQd0tFIxvhADtdgBQebUPwS6e1zJ56BNpVy6wfjg", - "de+VCOz4zYgoWF5wMEwhQIsMStnvcPlOkNewFwPF4ZHAhWSTuom90W6VUQ2McUv0ZOanaIWA2J6VPeb6", - "blBS7dZ11DoDtKjGvr6tAKNE5bX4LewOvY8zi6ycOzkzLNlQ2oUjfVIs8++np1iiwGoOdROvdCmekN+Z", - "kk5YDUPZC9Hoxl0acJcf9SzRKRRW0b1u3SkPLFiDi9/BHQ4WgLq8fL+hPS4DYLoFf3GzGl57z/jFQCmR", - "+Iy9qczVELllJSCcccfGNjGXfYsYLWBfo/oLsY8XEplQUAB329VUAWSh64EyJjtPc77zNHeM38rAtPbS", - "IaYfTpNPJ01irqu133HskYrrHI5RbCpK9acec/mD88Ao1PAS8m2Rw8+6Az2GTemUopfoEzSiW6lMO8bL", - "w3dGHAlJJ/LWrJx7auZtc956HGOafZnwXVvR6qjV4/YSjwjiYZ8DNuhx0OQ1cw9zIpU5jtD4Nlhe01sj", - "EyzjgWv3o6ePEL5201nRuCqEXsq6LLAwxApysTUyZuJ0XAGowBc2BbnQjQO8LuIgax3NEG82IS/tyLRc", - "0632itoGs4aH87uK5SMSSsI4WSNql9N7o3J0E2c5rzgTJvjcxOdikXxYvZke2KlJLdXBLHL8OmgtnOM9", - "bSqptU1v3vLmqkXR6IWeum2mZVtdgAN7VbRt88yP7VcUjjR60PanFEnV0wtbuofoOdvoTmrn9IqHEjns", - "hVQOpxkmb0KKdgDwgFFG2Eb20F5TddV6BN1ldQOIBaYTaI3a4jGiJACalZiKtBODPBQho1npTBk/1bOS", - "52BGAKfvYFhwHv8FeUNFIVfkhU/m8+CXNy8eEsV0XRqPZD6zsUU+B8nHLScwuPBKzd3K30bRMmH5XDiL", - "yoJroxKKy3tfFeR83OdwZBvNtWm8jtBgjekeewHh3FHB9DMEE16xbVbwsh5EZNvqqmgn3NT1DMrCcYFZ", - "eWfU5ODN0gNB75h6j4eDbVPiUsHN4bYrHXdhYLnuxrRmqTr351NDoD2ihDev7qaeznJzKPl03ZB+uplu", - "xh8ie9iESUSJgO15+oIonYf/VlxWNAXGaVnuQ7uqhA2z1XYpbYp+iuAZGhkS9rqctsdLu516PgsmgcJn", - "vM9x2Qnh9XdvS8MZQf/CFSstI+ZnXotCd7awKYe/w/66k/dxrI9vs9OUO8QUjOUEWkGzbUjAcOmCTpp4", - "aa1lzhsjPNSaxKqSfxfl1iWl61b0aLayUvKaF6lC9KVc8FyjCuZQi/Er3/fDdLKqS8NvOM5r3xdN2Onn", - "kC/cUygKqgrCisfffvvVX9qpED4hctXfpKR7j1uW0zJSw/M2HxtWN4KI+aM8W8g+yRo0tqlFY3sIxrVU", - "4tbxNjIAZDj03StanYPIbEtohOrSsu2l4c1PU/vbkuplQzqjssVQRpoSR6+6Xn8QXxQZ+u45/NwhdnYr", - "x4zO9RgiHM0l+RTuRkweER/GksTXESXprXDlloh6V4svPugS9roqmeXtGho4mEbHHw0++X7Ot7xf5T8e", - "L73r0ABKB0rLiWBeVstMNhwXKAgaqG7gHdzbn7cxXKm8eEvFtIUo7X2zVMlMI7vybzaZDxN51Q8627ed", - "Pe1kJoF9G+Rwq6uPlMBmFw58Glkc0o5Yu1nmoVwMZExgXkhG1U1CNcw9R1lhd6H+YL7Vtvw8PqOJA6fr", - "5TbknqYr76D2LgodjTN0kZeI/o1XI/CxAvPVuJR7aPx1BQDa+3X7kPwPECEwl5jdQBiamya1+OSJG2ni", - "ivxOlsZU+uL8fL1en/lpznK5Ol9AlFNmZJ0vz/1AkEaylTrNdXHVr+yzW24NzzV58tNLYJK5KRkETMDR", - "RQl1LyaPzx5h6kUmaMUnF5Ovzx6dfYVXZAl4cY5pjicXf3yYTs6vH5/HzlGLVODDW0ZVvkQ0dm3PII0g", - "Q3H2ZREavZDqiR/OGbrARjy5eN/LEAeqVQgT4fbv32qmthNfGD3W+zXm1z493B9Aj3opjR6/plaYkkAx", - "knuuPfItAPcBwq6ZIBwxseQrbrxKVDGaLx2bloAZ2h4IcFMLhS5YBO8Z+VmzqBaZvIKYI5QvfASDL6UV", - "Og0AZodIwdXQuH70OO6ak23AAZQKb2tZQJQdmMlE5Kl81irm43TzvvwdZjvNt6QWpWUovcEJ7MQ6LA3q", - "PGE6m5y6HXDhfd5NWg+fgJ8kcxBmFsIDT8TV1QZhGLgH59gNak0nKzscn4bMrbGnyBQN1nILue80s+1C", - "LtSOSWHqPD3ssPg5ckUCHwT0IxlasPM5z2hZppYZWRe7y/zrxi2zwX5cra7zJfgkdQHtQobZPF0mihBQ", - "5PZm6vpHfiI+NjP4h4SWorWBI/rY7WCbqpQFm1zMaalZensYLrK1NYEj9B64uHfOFaYTlarR+VZnkT/I", - "pBVRa1sIKdK5UnspCc0WSLd9dCaH3jq4Np/ulbNT3Oq+eb/byKnCyCa0HDKx2kvosjclX40QGz9M7fZ6", - "0+7+3AX/ueVKckBScI/hmpalXLPCVfkMyByKHrg7G14mxx86u6aLLTsjb9CvTUfxIM1Y4KujGBFy7VwA", - "h08olFY84FDi/K3Db3TXMWnHDL9aWRVLKsDle/zokWennLo5Gu38XxoFo2bAYYfuQ8LDUnfSV6faGXof", - "ao6iHRQPbo1sxKqqzbCzyMZk8Hj3R/5ZO7pZ0QUXzsUKlLgreoU8LgYKOg9Hf2F9pgXLEQTrnOMhHH6M", - "0KU2bFp7A35Nsr9tyB+Ap9NDu8BvbnWOg7U0hmtadNbhG44B+41DQPTSxlocH6aTbz/3JVikpgsNpVCA", - "DZ/8+qHD3J//4V2MefFhkNN/JeVVXQUbQVSvqs/wY1t3r55ugUjsZPiD5cGTYSApUP+goSgByEm8R0bV", - "7CD29d+TKJ840xNnej+c6Z281ge80Xf4JqffwdMzOPnm0Tenl/zTeclLeF/3vOTnPQqw72kXkWtll47K", - "CsltuW0/f7nLzbODAXhSVZD+AfTA+lNiBY4uyfxZn+WTavVGqtUjP6Wd+36ABNzM0tzUkzwcBVl1NvbE", - "EZw4gs+RIwghnR+FD/Ciyafz/t+JnfH05p/e/Ht788ONHvfQx9UzT++7f9+DEuX0qJ8e9c/tUU9kcD7s", - "iffayrQy81ZP/jMc+kkM2kn+P/ECJ17gbuT/FgE4VPQ/MQSJrContuDEFnzebMHhMn9gCDq20KOwAicl", - "wOnhPz38H10JcHrsT9L/6Zn//J/5OBZsrO9eO7XPu1axOcUc2WYFEWxtL5uRRJb2MdrzwscD7XvgT+/G", - "cWJxogpYdpY53zjq7PMuuYrCTT1QIQ3D7OuDUECmExjsYFd5jFkf8pQPX/9ITuzziceTHi8Vemr3+AIi", - "C+e8BL+9f9lN84hYNwk5gqenz4wfIlEha73mC5KFvAj2lxX+BLG2b/nC/lTiTxDljzHOqS3QfDG8Bxq6", - "rfAfO96oRbrLHy2kneBgtnXMe/pI0pzv8HQvE86y7U0M5byP7fvqp6SGWOFkjmFo8dQrLrKd04cGRwFh", - "xubSxd1EMNDNHhh8g0PjMu5UkPEri9a04JYAQ21r8trRGyrImxfPyNdff/0XgvfeCjaILkMLxiGxikgM", - "XKAbBTXh8xgq9ObFMwDgbXBpHdVq76EGjDrWymHET2/hf+IIzz9lmN19qlu6lwpX7UMsUKjEskq7uZRQ", - "fGmnwuK4gvafRECeTrpSxe3rKHYEpfZOdiY8hZn9W8mtY+zScR6JtvFlKJXEASbluzfzvgABAuWHVmGI", - "cOmQYwjZgZu0dkmCjs1uxnifNM4nzcHJ1PxnNDX/WwcrR/t0/kebWO8PWo6qww3pMJsm6YDlFEvcfTL2", - "ssV/OoPhnZGdA4nN/QWN3tKKdDLBfCasbI8Inc/kZpAQ/T/A/lnpv8WLwjWcyQ2x92rq2BfdyfwaGkBr", - "p3N46n5riv06/f5CujpouaUkVC2wnPMXMBgXiwsY4Isz8kIqwoGa1I4PwYZcmIuvHn/9jWui6JrMtobp", - "qYMHoCPffQPQ2K5fzL775gtvfaCQ0d3+dPHk++/dGJXiwtBZyZyGoTenNupiycpSug6OP2a9hvbDxX//", - "z/+enZ19MYaUy42l5k9E8SNdsfsn6k+as+MCjiY76om0293XpicZUNzf8Yqh274Mu4j/U7lJXXd7Z6K8", - "JSez/enNON6boevViqqtpfXMwLWPUM15y6ESoMON3vixYfrQ56Z5YaAie3hCILMqbXOBWirLYZZsw3O5", - "ULRacvuibM9G6WSeAnj3Tm9PyoFPSzkwXJ+54sWmUyqdcFGwTVp+D+g+StPwVG6euyllsgbo56AOwNuA", - "Cx9DmJ7G17l99U8v3emlu8uXDtFuxBt3kFbnvJQLfYBqh9j2I4SCV3KhP46O5/Q8Hcfr7SO7NP1J/Yug", - "zFEw1PdK4WMiXle7ard9C1tlTR3bu8nH++mzNXdq8yjlIvMvxuFpgBbPbdfPmne6hSp2lxJwd0BVbMmG", - "lrsEplHBUCfD7ulxPOC1avkiYIHke/RC2D+7HX2PFvGo89WCm6H57LfJ/UcLnsK/TuFfJ9H0Pr0H4JDP", - "//DXc7/HAFzzMUnObcPx0mRcsfzkK3CnvgJA5sbSwntMKg1TnsjNSZn3abs6dCnm+YyWVORsr0YOWW9t", - "QA3t6/aslxIIisuHDwRmJ0X1k51ko5NsdCpddwpsGhvYdDSm67jcSEw8R0lpr7ngp2ydqVdv1jwNJ5Ht", - "z8SAHJLqomWeAF2so0+78l1glgv7pGLmi50y3ynbxSnbxSnbxSnbxSnbxcexRp/yUpzyUpzEt3/vvBRj", - "PE6cEdMCKgVDV+ZWY3z+B7mQu3ZC6S3qmVzNuGCNAORX0BQLNdIeFDRaUhPeYd/QSKKDl8GedWVKlgPv", - "KzjhgFCcM34N/50rxn5nmaHKMtdj3tvWajyAUBozmj+ujXnQ2ixTjAo34vOBaFdGVa0gDa0JuWoJJX4l", - "U8snb2VN1nBZSn4F/V1dTbvpKyjI2qnRaiQxqh40TrvuGcCzN/PI9D4MQKckKqckKqckKn8CbcislPmV", - "Pv8DjjpDPcJeIzZ0GlJiPLUf9yku8DLidOm0UDFAtyRqPzBaMEWkffTnJV2ckX/Yywm3D1xLjafQ00Zn", - "A2skhWSoC3EKgC4PoAfo3xKmzOyUd0sCd0arwEmcAsM/4+s5SjUZeYaOzcDb1Uh6dj3NNnIN7HiXaQ9i", - "4mG5fYOX6knTedJ0njSdJ03nSdN5yut70p+e9Kcn/elJf3rSn570p3euP/2YOs+7rxV60qqetKontc1H", - "DQuKj/b8DysT7Q8MIlZ8LFsv5JCKNca6MdFBTii7vxxq90hCou066LKOv5ynGJoTeflUtMIfphPN1LW/", - "67UqJxeTpTGVvjg/Zxu6qkp2lsvVOSSpcP3/CHy/XK3goQq/uJGjXxwps903mVTcvr1lptd0sWAqszMj", - "zI/PHk0+/J8AAAD//3BbS4jifQEA", + "H4sIAAAAAAAC/yTNMY7CMBBG4atYf21ZKbbyDZaCO0ycCRjsGcueIKQod0eE9r3i25F0YcS/afJIWpsK", + "iw3E/fDIsiqibKV4VB6DboyIf2mbOe5de3Sb0FzYmbqk8uJuLp/7DDWsNIz7u5bwoPQcKmEhoznLEi5D", + "5fq1PbSxUMuIgEcju4+fenwCAAD//zUNUoGeAAAA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/generated/v2/types.go b/api/generated/v2/types.go index 36d8da56d..fa8fbb2c3 100644 --- a/api/generated/v2/types.go +++ b/api/generated/v2/types.go @@ -1271,6 +1271,9 @@ type Exclude = []string // ExcludeCloseTo defines model for exclude-close-to. type ExcludeCloseTo = bool +// GroupId defines model for group-id. +type GroupId = string + // HeaderOnly defines model for header-only. type HeaderOnly = bool @@ -1835,6 +1838,9 @@ type SearchForTransactionsParams struct { // * lsig - LogicSig SigType *SearchForTransactionsParamsSigType `form:"sig-type,omitempty" json:"sig-type,omitempty"` + // GroupId Lookup transactions by group ID. + GroupId *string `form:"group-id,omitempty" json:"group-id,omitempty"` + // Txid Lookup the specific transaction by ID. Txid *string `form:"txid,omitempty" json:"txid,omitempty"` diff --git a/api/indexer.oas2.json b/api/indexer.oas2.json index 76c11d21d..2a781fd85 100644 --- a/api/indexer.oas2.json +++ b/api/indexer.oas2.json @@ -953,6 +953,9 @@ { "$ref": "#/parameters/sig-type" }, + { + "$ref": "#/parameters/group-id" + }, { "$ref": "#/parameters/txid" }, @@ -1753,7 +1756,7 @@ "Box": { "description": "Box name and its content.", "required": [ - "name", + "name", "value", "round" ], @@ -2595,10 +2598,10 @@ "StateProofParticipant": { "type": "object", "properties": { - "verifier": { - "description": "\\[p\\]", - "$ref": "#/definitions/StateProofVerifier" - }, + "verifier": { + "description": "\\[p\\]", + "$ref": "#/definitions/StateProofVerifier" + }, "weight": { "description": "\\[w\\]", "type": "integer", @@ -2859,6 +2862,12 @@ "in": "query", "x-algorand-format": "Address" }, + "group-id": { + "type": "string", + "description": "Lookup transactions by group ID.", + "name": "group-id", + "in": "query" + }, "txid": { "type": "string", "description": "Lookup the specific transaction by ID.", @@ -3103,7 +3112,7 @@ "schema": { "type": "object", "required": [ - "application-id", + "application-id", "boxes" ], "properties": { @@ -3132,7 +3141,7 @@ }, "ErrorResponse": { "description": "Response for errors", - "schema":{ + "schema": { "type": "object", "required": [ "message" diff --git a/api/indexer.oas3.yml b/api/indexer.oas3.yml index 9a425b354..e27f42c64 100644 --- a/api/indexer.oas3.yml +++ b/api/indexer.oas3.yml @@ -135,6 +135,14 @@ "type": "boolean" } }, + "group-id": { + "description": "Lookup transactions by group ID.", + "in": "query", + "name": "group-id", + "schema": { + "type": "string" + } + }, "header-only": { "description": "Header only flag. When this is set to true, returned block does not contain the transactions", "in": "query", @@ -4907,6 +4915,14 @@ "type": "string" } }, + { + "description": "Lookup transactions by group ID.", + "in": "query", + "name": "group-id", + "schema": { + "type": "string" + } + }, { "description": "Lookup the specific transaction by ID.", "in": "query", diff --git a/idb/idb.go b/idb/idb.go index a4c58c948..5e423747f 100644 --- a/idb/idb.go +++ b/idb/idb.go @@ -220,6 +220,7 @@ type TransactionFilter struct { OffsetGT *uint64 // nil for no filter SigType SigType // ["", "sig", "msig", "lsig"] NotePrefix []byte + GroupID []byte AlgosGT *uint64 // implictly filters on "pay" txns for Algos > this. This will be a slightly faster query than EffectiveAmountGT. AlgosLT *uint64 RekeyTo *bool // nil for no filter diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go index 5ba34d67a..6d904b29b 100644 --- a/idb/postgres/postgres.go +++ b/idb/postgres/postgres.go @@ -7,6 +7,7 @@ package postgres import ( "context" "database/sql" + "encoding/base64" "errors" "fmt" "os" @@ -621,6 +622,11 @@ func buildTransactionQuery(tf idb.TransactionFilter) (query string, whereArgs [] whereArgs = append(whereArgs, tf.Txid) partNumber++ } + if len(tf.GroupID) != 0 { + whereParts = append(whereParts, fmt.Sprintf("t.txn->'txn'->>'grp' = $%d AND t.txn->'txn'->>'grp' IS NOT NULL", partNumber)) + whereArgs = append(whereArgs, base64.StdEncoding.EncodeToString(tf.GroupID)) + partNumber++ + } if tf.Round != nil { whereParts = append(whereParts, fmt.Sprintf("t.round = $%d", partNumber)) whereArgs = append(whereArgs, *tf.Round) From da7e571046979d85ac65a168f08869f46c3e49d8 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Sun, 8 Sep 2024 21:33:26 -0300 Subject: [PATCH 5/9] Update DB schema --- idb/postgres/internal/schema/setup_postgres.sql | 3 ++- idb/postgres/internal/schema/setup_postgres_sql.go | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/idb/postgres/internal/schema/setup_postgres.sql b/idb/postgres/internal/schema/setup_postgres.sql index 72e1a4cee..fa74d463b 100644 --- a/idb/postgres/internal/schema/setup_postgres.sql +++ b/idb/postgres/internal/schema/setup_postgres.sql @@ -20,7 +20,8 @@ CREATE TABLE public.txn ( CONSTRAINT txn_pkey PRIMARY KEY (round ASC, intra ASC), INDEX ndly_txn_asset_extra (asset ASC, round ASC, intra ASC) STORING (txn, extra) WHERE asset > 0:::INT8, INDEX ndly_txn_txid (txid ASC) STORING (asset, txn, extra), - INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES) + INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES), + INDEX ndly_txn_grp (((txn->'txn'::STRING)->>'grp'::STRING) ASC) WHERE (((txn->'txn'::STRING)->>'grp'::STRING) IS NOT NULL) ); CREATE TABLE public.account ( diff --git a/idb/postgres/internal/schema/setup_postgres_sql.go b/idb/postgres/internal/schema/setup_postgres_sql.go index 91d414b3a..5721e2c01 100644 --- a/idb/postgres/internal/schema/setup_postgres_sql.go +++ b/idb/postgres/internal/schema/setup_postgres_sql.go @@ -24,7 +24,8 @@ CREATE TABLE public.txn ( CONSTRAINT txn_pkey PRIMARY KEY (round ASC, intra ASC), INDEX ndly_txn_asset_extra (asset ASC, round ASC, intra ASC) STORING (txn, extra) WHERE asset > 0:::INT8, INDEX ndly_txn_txid (txid ASC) STORING (asset, txn, extra), - INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES) + INDEX ndly_txn_note3 (note3 ASC) WHERE (note3 IS NOT NULL) AND (note3 != '\x000000':::BYTES), + INDEX ndly_txn_grp (((txn->'txn'::STRING)->>'grp'::STRING) ASC) WHERE (((txn->'txn'::STRING)->>'grp'::STRING) IS NOT NULL) ); CREATE TABLE public.account ( From 54511e4da7713d17a151fb1dd4b66e7f48ec86d9 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Sun, 8 Sep 2024 21:59:23 -0300 Subject: [PATCH 6/9] Linter fixes --- api/converter_utils.go | 2 +- api/error_messages.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api/converter_utils.go b/api/converter_utils.go index f3b2e4103..3f30a6678 100644 --- a/api/converter_utils.go +++ b/api/converter_utils.go @@ -117,7 +117,7 @@ func decodeGroupID(str *string, field string, errorArr []string) ([]byte, []stri return nil, append(errorArr, fmt.Sprintf("%s: '%s'", errUnableToParseBase64, field)) } if len(data) != len(sdk.Digest{}) { - return nil, append(errorArr, fmt.Sprintf("%s: '%s'", errBadGroupIdLen, field)) + return nil, append(errorArr, fmt.Sprintf("%s: '%s'", errBadGroupIDLen, field)) } return data, errorArr } diff --git a/api/error_messages.go b/api/error_messages.go index 70dbebb69..71401b0d4 100644 --- a/api/error_messages.go +++ b/api/error_messages.go @@ -14,7 +14,7 @@ const ( errUnableToParseAddress = "unable to parse address" errInvalidCreatorAddress = "found an invalid creator address" errUnableToParseBase64 = "unable to parse base64 data" - errBadGroupIdLen = "bad length for group ID" + errBadGroupIDLen = "bad length for group ID" errUnableToParseDigest = "unable to parse base32 digest data" errUnableToParseNext = "unable to parse next token" errUnableToDecodeTransaction = "unable to decode transaction bytes" From 3e8cd45c58ccecd3f3e4cc03f051c95562a1f112 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Mon, 9 Sep 2024 10:17:01 -0300 Subject: [PATCH 7/9] Swagger: update description for `group-id` param --- api/generated/common/routes.go | 367 +++++++++++++++++---------------- api/indexer.oas2.json | 5 +- api/indexer.oas3.yml | 16 +- 3 files changed, 197 insertions(+), 191 deletions(-) diff --git a/api/generated/common/routes.go b/api/generated/common/routes.go index dc9baf97c..aa093f800 100644 --- a/api/generated/common/routes.go +++ b/api/generated/common/routes.go @@ -72,189 +72,190 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+x9f5PbNrLgV0HpXlXsnDjjOJvU26naeuXYScW1dtZlT7J3z5O7hciWhB0KYABwJCXn", - "736FboAESZCSZsZjb9X+ZY+IHw10o9Hon3/McrWplARpzezij1nFNd+ABY1/8TxXtbSZKNxfBZhci8oK", - "JWcX4RszVgu5ms1nwv1acbuezWeSb6Bt4/rPZxp+q4WGYnZhdQ3zmcnXsOFuYLuvXGs/0ocP8xkvCg3G", - "DGf9myz3TMi8rAtgVnNpeO4+GbYVds3sWhjmOzMhmZLA1JLZdacxWwooC3MWgP6tBr2PoPaTj4M4n+0y", - "Xq6U5rLIlkpvuJ1dzJ75fh8OfvYzZFqVMFzjc7VZCAlhRdAsqEEOs4oVsMRGa26Zg86tMzS0ihngOl+z", - "pdIHlklAxGsFWW9mF+9nBmQBGjGXg7jB/y41wO+QWa5XYGe/zlO4W1rQmRWbxNJeesxpMHVpDcO2uMaV", - "uAHJXK8z9ro2li2Accne/vCcff31139mtI0WCk9wo6tqZ4/X1GCh4BbC52OQ+vaH5zj/O7/AY1vxqipF", - "zt26k8fnWfudvXwxtpjuIAmCFNLCCjRtvDGQPqvP3JeJaULHQxPUdp05shlHrD/xhuVKLsWq1lA4aqwN", - "0Nk0FchCyBW7hv0oCptpPt4JXMBSaTiSSqnxvZJpPP8npdOF2mUE04Bo2ELtmPvmOOlK8TLjeoUrZF+A", - "zJXD48UNL2v44oz9oDQT0pq5xzX4hkLai6+efv0n30TzLVvsLQzaLb7908Wzv/zFN6u0kJYvSvDbOGhu", - "rL5YQ1kq38Ezs+G47sPF//rf/312dvbFGDLwn9MuqLzWGmS+z1YaOHKcNZfDPXzrKcisVV0WbM1vkFz4", - "Bq9O35e5vnQ8cDfP2GuRa/WsXCnDuCe8Apa8Li0LE7Nalo7Vu9H88WXCsEqrG1FAMXc4265FvmY59xuC", - "7dhWlKWj2tpAMbYh6dUd4A5NJwfXrfYDF/T5bka7rgM7ATvkH8Plf7/zXLIohPuJl0xY2Bhm6nzNuPFQ", - "rVVZENFHFwArVc5LVnDLmbHKMdal0l7iIa479/1bIY7liMCCLfb9lrLojH64j9sf2FWlcitb8tJAer/C", - "6uNNwlXGsgUvy5m/sZyg5afMmh94VZkMV5wZyy3EbarKtZBKQkIAaX7gWvO9+9vYvZOykLXOWuxkeakM", - "ZFYdEMCCTIUbFolM8Y6dJI6xyzUwnNx9IFEUKVs6Ll2We2Y9AhxBsCB8zZlYsr2q2RaPTimusb9fjaPp", - "DXPIR5R1JEXHzcaIe7AZCdJeKFUCl0jaK63qKiljvFLquq66Mvliz7ADe/liDIBmwGl+uwZegM6ULPfD", - "qX/Ej8x9ZMuSr87Y39fgmYiTOdyu0DbMmQZba+mou1T5NSsUGCaVdfKK5UL2nwpmBOwYngNb5l8rmSP5", - "cbmpDKyAmjsRCXFSNCLVnBVQAtJFe27xV2O12iO9uNMzZ6py50TVdshPZOGHpc999oJnbfRhFK/kwKJL", - "sRF2uNzXfCc29YbJerNwGFs2MpZVHjV4PjSwHMl80WGWFV+BYeBEMEGvOpzHIdnhUAPP1+OMnGA6wLs3", - "fJdpVcviiMeLZUrHwqGpIBdLAQVrRhmDpZ3mEDxCngZP+6SKwAmDjILTzHIAHAm7BFodR3NfEEERVs/Y", - "z/66xa9WXYNsbmW6X4BVGm6Eqk3TaUxKc1NPcwmpLGSVhqXYDYF857fDMVVq42WCjZfjPQuAgnk+4IYj", - "Bj0KUzThqY+VBTfw7Z/GJPX2q4Zr2CfvqT4B0HIa7cjafaG+06toZjhwqI+kQxJLYvqbpL2j6A4bZcQ2", - "EmKl++qZSloT1el/hKgfz016kOxOOikaI0gEY1vRm+njPX+NWGU04uCUiNWlE1+WokTR5p/ucATM1sbd", - "S13cBmHHiJXkttZwcSW/dH+xjL2zXBZcF+6XDf30ui6teCdW7qeSfnqlViJ/J1ZjmxJgTeqosNuG/nHj", - "pXVSdtcsNzVF+JyaoeKu4TXsNbg5eL7Ef3ZLJCS+1L+TuIpXoq2WYwBMyUzthuYdPeViPyE54ZBT/BB5", - "h6mUNIBU+4wEibf+N/eTY3kgkaNHssD5P43Cx1s7dqVVBdoKiPXC7r//oWE5u5j9j/NWj3xO3cy5n3DW", - "PA7t2FVGB5hbz8KIdXmmRsLApqotXe0p7tAc5/cNbP05W7SoxT8ht7RBXTAewaay+8cOYA+7ub/dMp2H", - "0JH71n/MfMR9pMs9w0t6OPLPxj84K74SEhc+Z1snZm/4teMKXCq7Bs0cLsDYcM0T+6Obv1Foe1nBv1HO", - "ZqkTk8CpuTNSW6y9cuLuOxR37wPFvefqCbhOgfRvzDeYH2zsfZLA6p5wP6npv7p6z6tKFLurq187Ly4h", - "C9il8fFRkV2qVVZwy29Ho6sXrmuCQD9nGupaUe6LgO6XeE7AwsPeqPe1Xfd82G7FY//NWROn4u5M1Riw", - "3/GSy/xertOFH+poDL8WUiAQP5Kq699oDmhutvI+UOx3914OMmn6jz7C/0Zu6gw39pM7o/a+UHoUIh/4", - "RYhT3scmfSrC/zfF3y/Ff1eq/PpWuJxCFY56aGa1u/951S4163dqx4Qk7Z+XfL5TO/hcnzwLB9vRx+I7", - "tXvhp1T6X/s1Qgs/hoK/8/44Bo3LMt5Zt+TvtVb6HrAb3oY9eOazDRjDV5C2vcRrDA2PWVQAGBECbgmo", - "of4ReGnXz9fwEQ5qNPaB43rZKmPvYWM/KsuO9MaH1h+t6sBjrzvsiVw2msZ87rv3+bCLzpYfzxA7OO2z", - "w+NxbE5D8odgf4gNDAlXQu8rHl1HDlPcu1OSefBKXskXsBQSrf0XV9LxofMFNyI357UB7R+YZyvFLpgf", - "8gW3/ErO5v0LasxWh65fHpqqXpQiZ9ewT2GBfNISIyjLy8iBIXJP82bj1gIxpDMaNXPkoGqbeW/YTMOW", - "6yIBr2mM1jgy+clNzTpnfmyyrXtvWz9+mvYHvlZDX/9JNzQhu35iDpE/Kest0HzLiJBYbcCwf2x49V5I", - "+yvLruonT74G9qyqWs33P1qnNgco2r7uVY2Oi0UcZrCzmmfoU5ImFFNv8KYtS4Ztuw5zWq0033iflL4r", - "3sRO0+TH3VTRsnBF76jXh3n0jOihCn9nayiHDnynIiZ6c98aLwfe7RMu5ZdR5ANfcSFN4O1GrKSjau9F", - "ugCWu7scijP2csmQN807gRM+BMTzvYYBCEOOn+zSrQtdJFjOJTqEVgW64AnJuNz3jbIGrA2W8LdwDfvL", - "yMPiREu9d8fiBy62onbDNZdbi1W25YZtFFrpc5C23HsPrwQJpoGphbTkatJxsRwAEjk8ulMR6Q/HXEYj", - "ZzZeVWxVqoXnHQ0tXjTEGPqMs4k3DgBzDywi+Z7uuqAeWj0dszFX2dNX58a70yGbXNOtiWsptEE/QeCe", - "1fP4MNyCxrwT4xCUv68BpSil0ZmvS0cmHN4UeTc+SuhsCdKKG8igFCuxSMVX5bxzYwYPW+8R2oxgmFgy", - "YQ3zKlQHhJBMc7kCJ704iUMZXlI0SBKakhubrYFruwA+4jeHiGkd1DvLdv3Z1rEsJUshYe42B3aOjoXb", - "CQ0StlC41Qjt2zB3h9cjVz0CRICnUHAUPKE77iHuWXqujZCZ37qEI2iQX5rdDQJqcAuMjxLCRd83gIET", - "auvw4qBQ3ud/4NFeuydoGrSKaytyUR1ndyNA3nT6uEEOyW5JaU0t+0LZQH5KgkyNM7fm4Uy1IW9xt65w", - "2YXR6d2DUJ8xdFXzm7Qo0YG8idgifHONnu1hqRTBNAaOGROPw+TdtceHbs1NOHgYnxHuiaMk1hFm1pKv", - "46MR/cbvDuHmLeGGj+30uG8c+ob33d1QhBjGVwSnUopADT5xwREueL+5fx2/q8vScZtaXku1dc+ZU/zb", - "5jM68kOAbxSKKfQ5EIYH8QsTocbB8bflEvlHxoQs3CHCRwe3IVxG5YKiElqe7Hj5yv145gZw1OUGOHqE", - "FNn6IVHCVqqkgdlPKj5/cnUKkBIE3is8jI0XTPQ3pF/hKKajxE7+9EKmKS4Pp9y9EzpSEQKGMU4LAElu", - "+UzIOXOs7IaXjpVZRaJpM0j6qfWo80rygrt5PPYES2uIaEUouZy0JpJ1brOaWPwPQKffJhMQL9Quw5jB", - "IawY+ldVWcPElCz3FGHTf6fjCG49KkcKCV7K17Cn4B4MN8NTghpZzz8WUCon6asBhbWIOgD8XQG/R2im", - "BfwUNRskPZK8W7KbCBE7OPWIfD1Gdo+Qhu4AQF//3jhXew3PQaVMV5QZXvztbThvndmJI6fZyNhRHBJ8", - "l4qSWBzZ36Ear/FpfdOXfpLKuk4rRk0WXg8VvYVSt59jR7mSBqSpMQrTqlyVZwMtnYES8BmRdQSy7BoS", - "QV7vQuNIb8ceiaV7nz+OXgcaVsJY6MRHNvEHbXjFHmMKK24taDf8/3n0Xxfvn2X/zbPfn2R//p/nv/7x", - "pw+Pvxz8+PTDX/7y/7o/ff3hL4//6z9mI9cyOHFbLdNreqtUc/FhY4aNO0t7cKhvlIUM333ZDS9T5r0f", - "8FGYlLQ6iGQUxCtGdO440TXss0KUdZoWf2q4oKkXyKmFZMAdJ+Q2X6M03ZnRtZmYDd8/I6t6xe9tUUeQ", - "s3ao7w78L0LXPX46dYgTxJRC+xA5o/s4wdZQMnoBJRkvx7Nt0EErXMOzKcPB4GAUYeyp12IExfjNQyMl", - "19L1Bx1fBVrSUW4RNor3NYMVHasD2jYhs7EIuuWNkuuj63ri1cX6Hj9KWsXiP95hecPhj11eMi3Scd4O", - "iLBTVJYkAA1oCs+KH+wAPUV2keHl6p4Rxj846IBEwiXFwcu+kNmjsyas+DhcBFnBRzmrurkJp2XZ+6M5", - "SDy2aO0p8mNLrTZ42IayZqyAHNFLdKiuvVp6s/p0TUN6cfwSHygH7cDAy7/C/hfXFrHqegcJ89hT0qpp", - "wisvvDjuhJq72bxSlO9HPEj5FLQwRvaY2IdsEx0L9YknoFQrk4rxW7UhsTEVLMA9imEHeW1btWdPud7o", - "/x9WBuwbEtLhi5HPASWXmpYUcH/8WAcw9qZhjx8TYbyqtLrhZeZtuUluji2CtfeBZa30gbr8/tmrNx5i", - "NCAC11nz1kgvBBu1b4zPdi1O1FAHjMGoiAoKgP6V7o25wnQMwFtMKdF7ujrhyVMRbUxrxI+OqTcIL4Oo", - "faJ51zsZ0BKnnA1ahQ/5GnT9C/gNF2VQ2QcY01cFLal15Tj5togHuLOfQuRXkt0r/x8c3vRJOMBo4hkm", - "MkZsKG+JYcpnhmiR5R6jaBRAstzwvaMWUssOOY6sN6jZyUwpUmaxrrqSYauR96wbyl2tU4O47+YInVgP", - "rGjw5PYFP/+x3Voo7+xWS/FbDUwUIK37pPHM9Y6hO3UhcdetXy8JCzYl+HrA9wtOeMrLxeftudPimlFu", - "835x75OENZGw5tfT4O4u75hWhTuU4xCI6UdM7EQ0APdFo5oMVNRYGLjsmJFP8C6MZxyIDSOegdG5k8Lb", - "OW6BlcNpPMNDyed1SvOHk95BcZqoO71+TLbU6veUF+12OG00IfVKD3r066V3TkZeMaKXZu8WKGoSbN0V", - "pObVe2eg+rdjY9toc7u2yBk9ZGNyd2yD6bqkjjByPG8YBsL11dWv9LAMdl4u6YA9xxyxnSdP+pjGDsrn", - "NH57TD3MQ30E3y54fp1YTOsV2LFEW8VCpyZlWhc7ZyxyMGza+uxjFeiNsF12376obivZ0rRHy7StCIvU", - "FAuvPudjaVRimFpuubQhh5xnYL63ATLpuF5bpY3FLJrJVRaQiw0vR8x7LYMsxEpQ0rfaQJSyzPdnlRLS", - "EtEUwlQl35O7ZbsjL5fsyTxiXh4JhbgRRixKwBZfUYsFNyiLtBqm0MWtCqRdG2z+9Ijm61oWGgq79tn0", - "jGLNowMVNI3nxwLsFkCyJ9juqz+zR+jlYsQNPHab52XK2cVXf0YLI/3xJM3LMd/pKG8NLD1NtejTQ13d", - "pegHS/Nayu990pmhLsecGGzpGf7hE7Phkq9S2b4mYKE+rV2/tw+yoFSdKDIxYdPzguWO62RrbtaptMi5", - "2myE3Xh/B6M2jlrahFg0VxiFbPrErhtwwkf0QK5YWrn2sBqfdA7on/gGups4Z9wwUztQW6WVZ25nzKeC", - "KygXZ6tNxC2hVNLkkUY632WU6Lm2y+w/Wb7mmueOlZ2NQZktvv3TENLvMF8ew7zUUNBcxwP+4NutwYC+", - "Oe6gBTHJ92GPpJLZxrGH4rHn1N0zN+rOlGbLfYeT6SGPlZHcKNk0VfGIy96JvuTEgHekuGYZJ5HdySt7", - "cAKsdYIafn77yssDG6Whq1tdhJiijmShwWoBNxh6kcaNG/OOKNDlUZt/F+g/rQ09CIeRABVObEpUp0Dz", - "4XZ4//Vm2WOPXqWurwEqIVfn5L+NwjSN2hejF0rWIxrLSjnZSfCSYSNW8b3b5UYEnfANXwKYLFdlCXny", - "jdqLvnLNWcUFHZs4w2ZwfJyYawUSjDAj1/nV1fvV2r1Q3Gd3E0daFgoIIJ878/BHNAA+EmG/Aungfvni", - "ENSDgbtuFRTqdFCH0/EH+9n3cYP59L0Zzju+y66dg/dNSPdLcLr2D7+1PoZBjxC2/9rw7z51Hav8DwNl", - "dDTGwlFtzcsQ24nUvQTtC6d0wEEdDJa2AGBGyOuDvvkH01W89W3Hneqvrt5rWTjMPffhc+Qj1bVjEzK3", - "HO0SIIsW+nzNxYhPqgFIT+g+uBnfKW0FOe0AfGIHPqt5fp1UQF66L6Zx4iNP+8idzxwdyIXWiDeuz2WY", - "LWWMFRswlm+q5N5Z43aO7gK8V9z2NV0cwzSQK1kYR0E5MKiUWR/KKGDSU+0kTlYKQ7JOzJlzpSn7LMqu", - "VvWivY/dksm49i6MmVbKjgHq4OwkJFDKMl7btbvCQhwBYK2A/koo+g3frTIKemKvnZQR8vbystzPmbBf", - "0Djae3ZytgF9XQKzGoBt18oAK4HfQFvMBEf7wrDLnSgMliopYSdytdK8WoucKV2Apio3rjm+pamTn+/J", - "GfNRvT4O4nIncXlNcYN4nbTMEL3SWLTiFc9JhOv/jDUmDJQ3YM7Y5VYREKbNbWCc9NstAFFbihksxHIJ", - "yD1wOfgUx37thwgmLMuCoQbNsH5ND88DBhSWmTV/+s23Y4T29JtvU7T27sdnT7/51knCXDJe70QpuN7H", - "zVyrOVvUorQ+0TZnN5BbpWONg5DGAi8GtEXaKD8LyjLLWubeDa3pEhfPeffjs2++evp/n37zrVdfRbOE", - "KGgfYAfyRmgl3aegMGwoxE/ZzAY7YewnkJbsTmb4Xk7d6g41OaJlJ59TI+YDL7rm3B4L25B+Khz8EooV", - "6Hl7ETu+2uYccY87pSMJeAkUIubuRSGtVkWdA2W6eNfhGxFYYgBSUz4hcrfBsx6qF7VwBk1qI7Mw9hJf", - "wE/oQSZVd4V4xuAGNMX0tAM9osshgstYrtFPCd2W/FKheJy+2utqpXkBx3kh4GX1M/VoEjeEEW7UaQP8", - "4tr3H1idN0BHsk4LsFEgh5NR4js3dedMcInR99vbsQjKH6gikIaSQt2wMgq2nQ9eZ0uAzAmCSYp3ryZM", - "wJXnUDlKjytgAri7hk46nmWszBeEtiYImoLw0hoshCnLeZnXJT0lJkTIbc5LtAS1hF3C0ipHe3GFr9YU", - "INxcC/QQp5IiNJ92d1jUA9NG3YDe+xakeQkVPNy50T3XnaGonJVwA2UScOAaZYcf1ZZtuNw3uHBTtGDM", - "o8i4BnISgtFDhLD9s1cKReDTOfMEOQ2kQ8XI5hYxnivQQhUiZ0L+E/xBj58OSDFUCkhJK2SNRac0tHDT", - "Vc8wRLcfhjukAJ10KXZwcQsOsDaKQ8K2g+0ieih0gyGM5ddAYIdgYi/dHItTDUYUdRqypeZ5F7LTiNEf", - "3rfcwrluUGvuiS57zKs55FOHrk/LPbLpYWu4S6N8qsOXj2FWvIn4Yp6HJ5zFfQaq0HJEY6Cswks7yt3S", - "jH0D2nTdkCMzAewOjO1adManvFwhtcHps2TBH82MzrcndtzSXJCfKfAe+/u0CqkdHEla1gBgtsLm6ywV", - "OOIBoBYOhrf9J/xwSpIu8BTCcgm5PQYGjNqhilijUNBnB8UL4AVGjLdRVxRv1Qfl0U+KuaFNJPJII/Ah", - "0Uo8OMrjExKaNxRyiPh/UUfSvg+4R0+II45BkHE87pNb5tt44nnZRL1ztgeDu9J4l0dnBDOTpE28YdIC", - "Sr6fmhIbdCdtZN5g3KY7BxN4uAuFvNlHg5DD1P6cTU3umvQX3BzP4amIS+0MMKkSTm4hl2YTQuWzEiZ8", - "NpM2LEfMfINkHMrkztmiY5B4eKPi/aTFSMc1huCTwTbgl7AP+Ed/Iz6xdSWU9/X3JK3k1zShREllkyRT", - "NN+jkGiKM8D1h+R73FevPZKaepasQFGfwb6l9un7G16OBFq+hUqDQT0BZ5ffP3vlnWLGwi3zdKTj1dV7", - "bh1NYT82mmzqw3w2khni6ur9Ajkm5X1osDG0LiZ9qB0jEq67+zzofTuXvLEkqtGGBl/8IUB/DQFgrOLC", - "O3q1sabDnfVBx8Po7mOCyFoE9xfho3pHj9CP3Kx/4LlVej/M4Oqe1iOpda6u3jt8n7LFX32bZvcOhPQk", - "l1H+nq6KrPH/Q9+7IA+p5SCPD8NEPmvuNWfhT/fSj5L2NN9n89lAD9DiIs5DnPAzWuNnym3IQiW3IaZH", - "0zUXi6wJG0lVdJzPfLrlOMfswVAwYbKNWGkUedKjjqeJjq6oxA1DonaiHLMXa8Zl8R6Rdhbeg7gFL7oR", - "/Mwpgn4pC9iBbi0zr9vV9SzlpD7CwsAma5Wpad5ExP6w8gHF4bspjIViQluzPPEoksdP6cS0o8Yvbze+", - "zFBMltkWxGqd3tg3txraidGHkXbz8EhLMbjXqPV/5g4kUuQIo122bHgyGXrEsdE3wI7Y7+2alv+5hKRq", - "cG+YagRcW5xICP85stn9ykIJRm3EpirJ+dOzkkHuq5MSTbQBJh8/Xum+gz4+evgG3Noj8f6jNm4Ly+GU", - "VNOxGn+Tz9WmKmFceK64JPF5KaR/t2/X3MbF1IMNSOV5rVsjbj8a4xdeCqryazCLoVSqwrSFlRXS/QcT", - "OKja0v+Ba/cfcirq/o+oKpKT3FAzxAsmvwoDhUjO2XxGnWeBspNSVNIxabAp3XRWAZ/ohI22NAlQYEBC", - "m036nOeW7J/eWVOC3Sp9nXjGLAzqkzp+VXHZ1yE35drWFacnCm88KHwK1yYrXAOah8zUhrxrOv4TB3kl", - "7CpHa6cDWOjNzZEQNpun5A1ob/tQPqckWTkoTe0gYRPz4J2yphSrvmUCoKPcUIYvtMQ2t0IiqQbTvk2o", - "1tLxOznyFRq6bOZ6X1l1jm2wybmxus6tIa/Nds4BVbqNJuelw/Xz+iKFkwSUEWTPtCrTcAN8TE2Prlrw", - "Ww0OyWiqc41ZM0AKsccy7f4e09jprUVAYlcYCpoiB7tyH5JlcrfnG169p1l+ZRl7SxA3pRTQI29jVtXp", - "nls0VAp0w0ubjb5yvHzJ3vHSxmKEA8j7eTQeMuOJa0mCTY6ef4onh4Pp9iToFgzFlLi/vYW4P8o7cN7m", - "oiAJrHukbkBTLPTR5PBL6PFhPnvQdbxtTuyQK0TrO24V8aZErCGtYglfw3FqUyVzWbBofsPwbCR8BfHo", - "grR6f5s0Q2KVmVKdsLx3YvXOdTiwpaHZYE9LtQWduXknUFwGUyPF21DLTirpppYLjUeeElAwtxhzu42g", - "gU/aCd/l8F60Y/ecUniZK5l1Zn9YrkP8MkPqyposBwd2j2+6u1eFt/WpXAuZxF7IVTrzo2P017D/PHQJ", - "CY/jAT7RxDuuzMGHxk+NQ0NkZNp6IzIZCbuCzoEqEu65hpKmL5czca5s91y1/kUbkWvF0RmjTTkNAwnW", - "P/bQl7HZjSkHk7RymRJzU+fLfQWNU+6w1M6GV+G9he9wJwSffUylFXvbuCMPPUpzJS0XWFAnKdyTMy6U", - "FTKqVjd+9lmR7y/RzdzzNZnen3yDBBQZrmL/bff/4ZZZDfDwHq7XsM9KsQQrRgzS5dKt5K+wZ6HZ2b3J", - "FGM5kjoGP9Q8lBQT0OZ9YkrTlxV+idNLMeKjGCRtwl+GFWBBbxwprtWWbep8jbI7X0FIsIQGG/Qs703U", - "GT1kpOimB/PxgabiOQ1EYf8l1yvQzEfiN3VJggFowwWek9YbuB+fi45iPGWMO5T26TWlAoh4F5pOoxxQ", - "iexSAYxr2J+TZRB/vwUjGU8lNQIY5pX6iCDdKT1VnNPsAL1ed4yqVOyrk/ytAf8ejasOPq9CONG4OszW", - "duzycB14HGoDw3UeH40T723iiduu7VjPgOHmjhj0D9nxR0q2eHMv8nHsyxA+9o+v/sE0LEGj3urLL3H4", - "L7+ce3+FfzztfnbU9uWXaaem5Mm5P7+BphKAG8NPl6SObgHYng2VLnlD4bTkuOYuNCXRZbMseyFPsmCY", - "bADFE44RIFCqCpKtsVhZfINiAjgNq7rkFOojpATd6XRMph96/tud9Kou/PNyJ1NtY3ESW0fbkSoQGlVh", - "vl3l3F45OcqzlGNGo9uO2OZEakek7Cp3GfEHSunSjBgiTO8y5qUf40AJx6ur92YlUS0XlHEiZAlAAZgw", - "3KWmJnNAKPMYMhU14WzwW81LH64nMTjuEtP25NcgqYKj43K++i4DaWrtVYIOVhzPgeKHUfFlbtomt63l", - "OF4Q7Orqvc5J++s92n0yCMw8RV2dmFE45KjpoiquvXtijiWjc5Itd3P5hiG+GH1FDz29kIz1ZtyG38sW", - "HUeWYMbF0H9k+LZ+SVsKPZ2LsE0q2buZKf/9o5cvHjPRL4YeZ32MHlqHlx2XUDkOIsowMoCln3vyFCiW", - "AGPhPL3AQraEEVXwZPkONxa+CqmOB7bqu2AfhPLIrAo/coNVOnzzNpL+c0yl0AGSvXyRlDM62XFPLgkx", - "n620qtOR2yuNpqG+L6h7BKCARQ94ci47f/rNt6wQKzD2jP0dk+vR5Tusi9bFJhNtvbVOKU+GgDUJWkkM", - "8sGI0Zxrj9BBcLDwQYk4zMNj+Db5yeczlEsyu0sFuL8cyCys8hGcmFs04jcdt/f7CGsX0mpOzDdTy2Uy", - "3+7f8PfWLUIHnqxhiPUjuPI17DXcVnb5K3ZuSoyOc54SOQ/W2rkd4ymBj0QOlLvE8fn6adaeoDP2yvVm", - "IJdKu1f1pkZLH+wwMZ83uMVSKqavs215aMxcJ38HrVBpIJnyhu3+GWs2G6MseY7yvPFRxA6GJrFuo5h8", - "9A6lmTkB+ZjepMOjxmppBYk/bht/iXaxchePA/rva1EmqKBS7ruJ4ZgzqZhC56C4JaU1aLMuEsw+LLxD", - "SA97zON04kXa1O8oAeMhX0W1NVqNRL7msq3Yfrgkw5Amj6vJPChKlDjm6YoRbgErWsDqXuD8tI56Uo2E", - "h7oPKIZooAyJjfbsgZMB8f0GpL0l53tDvck3AevZ6ukXgB55AYTeh+oAX8M+syo9NpBhiSTz5qmFelLi", - "ttEa5yPvnibGLtTAb2VXOkFORFjWaNCNTJdBT+qfdI0/2TXsW2+XuFYgPZtu8cqiazGtBb8UG2jfJSTI", - "pUQgcdSVSM/L9LuWciIRy/5iYjnNMNNUYUaogvpO08TRdt6IbCND7yDP0S1OQeSGhLk4JsI89hV0A/vQ", - "MbFR1HWSXKDO4Iy9aJLEoB8ixdq3mWNIn9X3VqSMKE2WZKGD3ovroK9Gh0Z0dsNTk2AEvgHJRq7NUEry", - "TXi+xAZjiqDQbLcE3bZLKWNCy6X+vW041AOFZlWFngUjGi3fytgKjUNjmG6dMiu+nwVhcDafuWW5fxzY", - "7t+l/t39U1UlVjmtlkOfzPQB9jSR4TyJEPdZ99XaESSbk9iS1gEN6GQdPR+4u6QavM2teqp6MlagUzry", - "9ofnvCwvd9L7AQ7D3iY8L3lFoW+vvMdlw6EdG/fuu0Fr5blDbInhee5EvKJN+RDB+YVh/boplAhiWDll", - "whvzIIfuiwAxbXK9Gl03KqyGYqjIGdermtIPPcD6Dqxg5GXDK1H4hIzDQnZeZCO2UGsomNI+lZdY+jxt", - "Y5UcDpepot2rvMwo8lY0bLNQjFD63D1+oPLJ1pXM8saz3N2T7oVpFbsij+yr2Rl7STljNPCCGKwWFlJ1", - "lDrrx+S3W8CyzoGiswa7URW8M3eKOjW3DFK2BvSfSJRI+5esx4UYM/UIxsa4EklVXSR9Agw9HxYTw2IB", - "Utl/ITwdVZnr6uo9VHiwumUv4jiKqmqKdZXg9v23GgPgHMPGYUd0tEqDWMmRWuxIIEseLgLTR1fyOuhy", - "KZ9uMEa8GdwSjTh+OyaKlhcajFII8CLDUvYTLt8J9trsxUhxeGJwTbJJ08beGL/KqAbGcUsMbOZNtEIk", - "7CDK3uf6blFS7c511HoDdLjGob6dAKNE5bX4LuwPfUgyi6yck5IZlWwo3cKJP2nIwv0ZOJYsqJpD3cYr", - "Xcln7HfQyj9Wm6HcgWh14z4NuM+Pepbo1BRWMYNu/SlPLFhDi5+QDkcLQF1dvd/xgZSBMN1BvrhdDa+D", - "OP5hpJRIjONgKvM1RO5YCYhmnNjYNuZyaBHjBe5rVH8h9vEiJtMUFKDd9jVVkFj4dqSMySQ2l5PYnBi/", - "k4FpG16HlH44zT79a5JyXW3DjlOPVFzneIxiW1FqOPUxh79xHjiKNMIL+a7EEWadII9xUzrn5CX6jIzo", - "7lVmvOAV4DtjnoWkE3kbKJeBmwXbXLAex5Tmbia61za8utfqcQeZRwTxuM8BjHoctHnN/MWcSGVOI7S+", - "DU7WDNbIhMh44trD6GkU4td+OiseV4Uwa1WXBRWG2GAutvaNmcCOLwDVyIVtQS5y40CvizjI2kQzxJvN", - "2Es3Mi+3fG+CoralrPHhwq5S+YiEkjBO1kja5fTe6JzcxCEXlQBpG5+bGC+OyMfVm+mBvZrUcR3KIidu", - "Gq2Fd7znbSW1ruktWN58tSge3dBzv8287KoLaOCginZtnoexw4oalEYX2uGUIql6es2WHmB63jY6ye28", - "XvFUJke9iMvRNOPsTSrZDQAeMcpI18gh7TXX151L0B9WP4BcUTqBzqgdGSNKAmCgpFSkvRjksQgZA6U3", - "ZbypF6XI0YyATt+NYcF7/BfsLZeF2rAfQjKfR7+8/eEx02Dq0gYiC5mNHfF5SD5tOYHRhVd66Vf+LoqW", - "aZYvpLeorISxOqG4fPBVYc7HQw5HrtHS2NbriAzWlO5xEBAuPBdMX0M44TXss0KU9Sghu1bXRTfhpqkX", - "WBZOSMrKu+A2R2+WAQhmYuoDHg6uTUlLRTeHu670uAODy/UnpjNL1Ts/nxsBHXhKBPPqNPf0lptT2afv", - "RvzTz3Q7+ZDEwzZMIkoE7PAZCqL0Lv47SVnRFBSn5aQP46sStsJW16W0LfopG8/QyJBw0OW0O17a7TTI", - "WTgJFj4TQ4nLTYi3v79bWskI+xe+WGkZCT/LWhamt4VtOfwJ++uk7ONFn9Bm0pQ7JhQcKwl0gma7kKDh", - "0gedtPHSxqhctEZ4rDVJVSX/Jsu9T0rXr+jRbmWl1Y0oUoXoS7USuSEVzKkW41eh74f5bFOXVtxynNeh", - "L5mw09ehWPmrUBZcFwyKp99889Wfu6kQPiN2NdykpHuPX5bXMnIr8q4c26zuCCYWUHm2UkOWNWps06vW", - "9tAY11KJW4+3kSEg46HvQdHqHUQWe8YjUldObC+taH+au9/W3Kxb1hmVLcYy0px5ftX3+sP4osjQ98Dh", - "556wszs5ZvSOxxjjaA/J53A2YvZI9HAsS3wdcZLBCjd+iaR3dfQSgi5xr6sSnGzX8sDRNDoBNXTlhznf", - "iWGV/3i89K5jAywdqJwkQnlZnTDZSlyoIGihuoV38GB/3sVwpfLirTUYB1Ha+2atk5lGpvJvtpkPE3nV", - "T8Ltu96e9jKT4L6NSrjV9SdKYDNFA59HFoe0I9a0yDyWi4EdE5jXJKPqJ6Eal56jrLBTpD+ab7X7fj4+", - "o4kHp+/lNuaeZqrgoHYZhY7GGbrYSyL/1qsR5VhJ+Wp8yj0y/voCAN39untI/geMEFgqym4gLc9tm1p8", - "9syPNPNFfmdraytzcX6+3W7PwjRnudqcrzDKKbOqztfnYSBMI9lJnea7+OpX7tot91bkhj178xKFZGFL", - "wIAJRF2UUPdi9vTsCaVeBMkrMbuYfX325OwrOiJrpItzSnPs/ruiMAdHNSgJvywwBP0a4kTJWDsbUyFj", - "96dPnoRt8M/EyDx5/k9DDO04i2k8DW5ydyMeoT3tcVSQP1FBWV5LtZXse60VMUhTbzZc7zEC2tZaGvb0", - "yRMmlj69MyX+4E5Mez+jiNzZr67f+c3T88hPrPfL+R/BRUMUHw58PudVZbLIgHywfbDCT7ZKRPEd3+eo", - "GXoFKEPb9HzRr+d/dE3UH45sdr7AShHHNoVjpz/3fv6hbX/x+Pf5H0G1/GHi07lPSzHVfWTfqNrM+R/k", - "Pk2qimiqdKcO2//D7jx0qNHV7pjPLt7/0eMzsOObqgRkMbMPvzbk3XAoT+Yf5s0vpVLXdRX/YoDrfI3d", - "d5nSYiWkI98tX61AZz0G8/8DAAD//zr1w2zG4AAA", + "H4sIAAAAAAAC/+y9bZPbNrIo/FdQek5V7BxxxnE2qbNTlTrl2HHFtXbWZTvZ5x5P7l2IbEnYoQAGAEdS", + "cv3fb6EbIEESlKiZ8dhblU/2iHhpoBuNRr/+McvVplISpDWziz9mFdd8AxY0/sXzXNXSZqJwfxVgci0q", + "K5ScXYRvzFgt5Go2nwn3a8XtejafSb6Bto3rP59p+K0WGorZhdU1zGcmX8OGu4HtvnKt/UgfPsxnvCg0", + "GDOc9e+y3DMh87IugFnNpeG5+2TYVtg1s2thmO/MhGRKAlNLZtedxmwpoCzMWQD6txr0PoLaTz4O4ny2", + "y3i5UprLIlsqveF2djF74vt9OPrZz5BpVcJwjU/VZiEkhBVBs6AGOcwqVsASG625ZQ46t87Q0CpmgOt8", + "zZZKH1kmARGvFWS9mV28nxmQBWjEXA7iGv+71AC/Q2a5XoGd/TpP4W5pQWdWbBJLe+Exp8HUpTUM2+Ia", + "V+IaJHO9ztir2li2AMYle/P8Kfv666//ymgbLRSe4EZX1c4er6nBQsEthM9TkPrm+VOc/61f4NRWvKpK", + "kXO37uTxedJ+Zy+ejS2mO0iCIIW0sAJNG28MpM/qE/flwDSh47EJarvOHNmMI9afeMNyJZdiVWsoHDXW", + "BuhsmgpkIeSKXcF+FIXNNB/vBC5gqTRMpFJqfKdkGs//Sel0oXYZwTQgGrZQO+a+OU66UrzMuF7hCtkX", + "IHPl8Hhxzcsavjhjz5VmQloz97gG31BIe/HV46//4ptovmWLvYVBu8W3f7l48t13vlmlhbR8UYLfxkFz", + "Y/XFGspS+Q6emQ3HdR8u/v//9T9nZ2dfjCED/zntgsprrUHm+2ylgSPHWXM53MM3noLMWtVlwdb8GsmF", + "b/Dq9H2Z60vHA3fzjL0SuVZPypUyjHvCK2DJ69KyMDGrZelYvRvNH18mDKu0uhYFFHOHs+1a5GuWc78h", + "2I5tRVk6qq0NFGMbkl7dEe7QdHJw3Wg/cEGf72a06zqyE7BD/jFc/g87zyWLQrifeMmEhY1hps7XjBsP", + "1VqVBRF9dAGwUuW8ZAW3nBmrHGNdKu0lHuK6c9+/FeJYjggs2GLfbymLzujH+7j9gV1VKreyJS8NpPcr", + "rD7eJFxlLFvwspz5G8sJWn7KrPmBV5XJcMWZsdxC3KaqXAupJCQEkOYHrjXfu7+N3TspC1nrrMVOlpfK", + "QGbVEQEsyFS4YZHIFO/YSeIYe7cGhpO7DySKImVLx6XLcs+sR4AjCBaErzkTS7ZXNdvi0SnFFfb3q3E0", + "vWEO+YiyjqTouNkYcQ82I0HaC6VK4BJJe6VVXSVljJdKXdVVVyZf7Bl2YC+euWULQ8tlG39zLriBb/+S", + "4WXijinusRPgtlwXZu6/s3zNNc9xp3HZ/zln59j2u2akn9+8DMOMrLSB/FShgoAYu1Hbr2vgBehMyXI/", + "3J0f8SNzH9my5Ksz9o81eD7nxCKHOMLUnGmwtZbuAJYqv2KFAsOksk6kslzI/mvGjCw4hucIVv2DKnOn", + "cly0KwO3ouZOikOyKRqpb84KKAFJt2Ut+KuxWu2RpN0BnzNVuaOsajtkebLww9LnPgdEdjD6dotXcmTR", + "pdgIO1zuK74Tm3rDZL1ZOIwtGzHQKo8aPMIaWI4ncdHh5xVfgWHgpERBD0+cxyHZ4VADz9fjdw3BdOR6", + "2fBdplUtiwnvK8uUjuVXU0EulgIK1owyBks7zTF4hDwNnvbVF4ETBhkFp5nlCDgSdgm0OqbrviCCIqye", + "sZ+9RIBfrboC2QgOdAUCqzRcC1WbptOYIOmmPiw4SmUhqzQsxW4I5Fu/HY7vUxsvtgQ251kAFMzzATcc", + "MdVRmKIJPxbr03AF++RV2icAWk6jwFm7L9T38CqaGY4c6ol0SJJTTH8HaW8S3WGjjNhGQvJ1Xz1TSSvL", + "Ov0nvEbiuUlVk91KbUZjBKFlbCt6M328F7oRq4xGHJwSsXrnJKylKFEm+Jc7HAGztXH3Uhe3QR4zYiW5", + "rTVcXMov3V8sY28tlwXXhftlQz+9qksr3oqV+6mkn16qlcjfitXYpgRYk2o07Lahf9x4abWZ3TXLTU0R", + "PqdmqLhreAV7DW4Oni/xn90SCYkv9e8kUeOVaKvlGACHxLp2Q/OOKnWxd8LdyL7gkIf4IfIOUylpAKn2", + "CQkSb/xv7ifH8kAiR49kgfN/GYXvy3bsSqsKtBUQq67df/9Dw3J2Mfv/zltV9zl1M+d+wlnzfrVjVxkd", + "YG49CyPW5ZkaCQObqrZ0tae4Q3Oc3zew9eds0aIW/4Lc0gZ1wXgAm8ruHzqAPezm7nbLdN5qE/et/976", + "iPtIl3uGl/Rw5J+NfxNXfCUkLnzOtk7M3vArxxW4VHYNmjlcgLHhmif2Rzd/o3P3soJ/Rp3NUicmgVNz", + "a6S2WHvpxN23KO7eBYp7L+oTcJ0C6U/MN5gfbOxdksDqjnB/0BhxefmeV5UodpeXv3ZeXEIWsEvj46Mi", + "u1SrrOCW34xGV89c1wSBfs401DX03BUB3S3xnICF+71R72q77viw3YjH/slZE6fi9kzVGLDf85LL/E6u", + "04UfajKGXwkpEIgfSdX1J5oDmputvAsU+929k4NMxojJR/hP5KbOcGPiuTVq7wqlkxB5zy9CnPIuNulT", + "Ef6fFH+3FP99qfKrG+HyEKpw1GMzq93dz6t2qVm/VzsmJGn/vOTzvdrB5/rkWTjYJh+L79XumZ9S6X/v", + "1wgtfAoFf+9dhgzav2W8s27JP2it9B1gN7wNe/DMZxswhq8gbXuJ1xgaTllUABgRAm4JqKH+EXhp10/X", + "8BEOajT2keP6rlXG3sHGflSWHemNj60/WtWRx1532BO5bDSN+dx37/NhF50tn84QOzjts8PpODanIflD", + "sD/EBoaEt6N3Z4+uI4cp7j0+yTx4KS/lM1gKidb+i0vp+ND5ghuRm/PagPYPzLOVYhfMD/mMW34pZ/P+", + "BTVmq0PvNA9NVS9KkbMr2KewQG5ziRGU5WXkwBB50HmzcWuBGNIZjZo5clC1zbzDbqYBnXKGs5nGaI0j", + "kyvfoVnnzI9NtnXvEOzHT9P+wB1sGI5w0FNOyK4rm0PkT8p6CzTfMiIkVhsw7J8bXr0X0v7Kssv60aOv", + "gT2pqlbz/c/W784BiravO1Wj42IRhxnsrOYZ+pSkCcXUG7xpy5Jh265Pn1YrzTfeJ6XvLXhgp2nyaTdV", + "tCxc0Vvq9WEePSN6qMLf2RrKoY/hqYiJ3tw3xsuRd/sBr/d3UXAGX3EhTeDtRqyko2rv6LoAlru7HIoz", + "9mLJkDfNO7EdPkrF872GAQhDvqmx91zOJfqsVgV6CQrJuNz3jbIGrA2W8DdwBft3kYfFiZZ6747Fj1xs", + "Re2Gay63Fqtsyw3bKLTS5yBtufceXgkSTANTC2nJ1aTjBToAJPLJdKci0h+OebVGzmy8qtiqVAvPOxpa", + "vGiIMfQZZxOvHQDmDlhE8j3d9ZI9tno6ZmPevKevzo13q0N2cE03Jq6l0Ab9BIF7Vs/jw3ADGvNOjENQ", + "/rEGlKKURme+Lh2ZcHhT5N34KKGzJUgrriGDUqzEIhUClvPOjRmcgL1HaDOCYWLJhDXMq1AdEEIyzeUK", + "nPTiJA5leEkBK0loSm5stgau7QL4iN8cIqb1oe8s2/VnW8eylCyFhLnbHNg5OhZuJzRI2ELhViO0b8Pc", + "HV6PXPUIEAGeQsEkeEJ33EPcs/RcGyEzv3UJR9AgvzS7GwTU4BYYHyWEi75vAGM71NagA3PBlA9LGDjd", + "1+4Jmgat4tqKXFTT7G4EyOtOHzfIMdktKa2pZV8oG8hPSZCpcebWPJypNuTQ7tYVLrswOr17EOozhq5q", + "fpMWJfq4N0FlhG+u0fk+LJWCrMbAMWPicZi8u/b40K25CQcPQ0jCPTFJYh1hZi35Oj4a0W/87hBu3hKu", + "+dhOj/vGoW94390NRYhhCEhwKqUg2eATFxzhgveb+9fxu7osHbep5ZVUW/ecOcW/bT6jIz8E+FqhmEKf", + "A2F4EL8wEWocHH9fLpF/ZEzIwh0ifHRwGyJ6VC4ocKLlyY6Xr9yPZ24AR11ugMkjpMjWD4kStlIlDcx+", + "UvH5k6tTgJQg8F7hYWy8YKK/If0KRzEdJXbypxcyTXF5OOXundCRihAwDMNaAEhyy2dCzpljZde8dKzM", + "KhJNm0HST60HnVeSF9zNw7EnWFpDRCtCyeWkNZGsc5PVxOJ/ADr9NjkA8ULtMgxrHMKK0YlVlTVMTMly", + "T0FA/Xc6juDWo3KkkOClfAV7ij/CiDg8JaiR9fxjAaVykr4aUFiLqCPA3xbwO4TmsICfomaDpEeSd0t2", + "B6LYjk49Il+Pkd0DpKFbANDXvzfO1V7Dc1Qp0xVlhhd/exvOW2d24shpNjJ2FIcE36WiJBZH9neoxmt8", + "Wl/3pZ+ksq7TilGThddDRW+h1O3n2FGupAFpagwUtSpX5dlAS2egBHxGZB2BLLuCRJDX29A40tuxB2Lp", + "3ucPo9eBhpUwFjohnE38QRtescewx4pbC9oN/78f/PfF+yfZ//Ds90fZX//z/Nc//vLh4ZeDHx9/+O67", + "/9v96esP3z387/+YjVzL4MRttUyv6Y1SzcWHjRk27izt3qG+VhYyfPdl17xMmfee46MwKWl1EMkozliM", + "6NxxoivYZ4Uo6zQt/tRwQVMvkFMLyYA7TshtvkZpujOja3NgNnz/jKzqJb+zRU0gZ+1Q3x3434Sue/z0", + "0CFOEFMK7UPkjO7jAbaGktEzKMl4OZ4QhA5a4RqeHTIcDA5GEcY+9FqMoBi/eWik5Fq6/qDjq0BLOsot", + "wkYhyWawoqk6oG0TMhuLoFveKLk+uq4nXl2s7/GjpFUs/uMtljccfurykpmbpnk7IMJOUVmSADSgKTwr", + "frAj9BTZRYaXq3tGGP/goAMSCZcUqi/7QmaPzpqw4mm4CLKCj3JWdXMTHpZl747mIPHYorWnyI8ttdrg", + "YRvKmrECckQv0aG69mrpzeozSg3pxfFLfKActQMDL/8G+19cW8Sq6x0kzKmnpFXThFdeeHHcCjW3s3ml", + "KN+PeJTyKWhhjOwx9xDZJjoW6hNPQKlWJhXjt2pDYmMqWIB7FMMO8tq2as+ecr3R/9+vDNg3JKTDFyOf", + "A8p/dVhSwP3xYx3B2OuGPX5MhPGq0uqal5m35Sa5ObYI1t57lrXSB+rdD09evvYQowERuM6at0Z6Idio", + "fWN8tmtxooY6YgxGRVRQAPSvdG/MFaZjAN5iSone09UJT56KaGNaI350TL1BeBlE7RPNu97JgJZ4yNmg", + "VfiQr0HXv4Bfc1EGlX2AMX1V0JJaV46Tb4t4gFv7KUR+Jdmd8v/B4U2fhCOMJp7hQMaIDeUtMUz5zBAt", + "stxjFI0CSJYbvnfUQmrZIceR9QY1O5kpRcos1lVXMmw18p51Q7mr9dAg7ruZoBPrgRUNnty+4Oc/tlsL", + "5Z3dail+q4GJAqR1nzSeud4xdKcu5Ba78eslYcGmHGT3+H7BCU95ufi8PbdaXDPKTd4v7n2SsCYS1vx6", + "Gtzd5h3TqnCHchwCcfgREzsRDcB91qgmAxU1FgYuO2bkE7wL4xkHYsOIZ2B07qTwdo4bYOV4ptHwUPJ5", + "ndL84aR3UJwm6lavH5Mttfo95UW7HU4bTUi90oNOfr30zsnIK0b0MgHeAEVNgq3bgtS8em8NVP92bGwb", + "bfrZFjmjh2xM7o5tMF2X1BFGjucNw0C4vrz8lR6Wwc7LJR2wp5jGtvPkSR/T2EH5nMZvj6mHeaiP4NsF", + "z68Si2m9AjuWaKtY6NSkTOti54xFDoZNW599rAK9EbbL7tsX1U0lW5p2skzbirBITbHw6jMAlkYlhqnl", + "lksbcsh5BuZ7GyCTjuu1VdpYTPSZXGUBudjwcsS81zLIQqwEJX2rDUQpy3x/VikhLRFNIUxV8j25W7Y7", + "8mLJHs0j5uWRUIhrYcSiBGzxFbVYcIOySKthCl3cqkDatcHmjyc0X9ey0FDYtc+mZxRrHh2ooGnzL4Ld", + "Akj2CNt99Vf2AL1cjLiGh27zvEw5u/jqr2hhpD8epXk5pmQd5a2BpaepFn16qKu7FP1gaV5LKchPOjPU", + "ZcqJwZae4R8/MRsu+SqV7esALNSntev39kEWlE0URSYmbHpesNxxnWzNzTqVuTlXm42wG+/vYNTGUUub", + "EIvmCqOQTZ/YdQNO+IgeyBVLK9fuV+OTTlP9E99AdxPnjBtmagdqq7TyzO2M+VRwBeXibLWJuCWU7Zo8", + "0kjnu4xyUdd2mf1XlI30bAzKbPHtX4aQfk/ZTH2aUpprOuD3vt0aDOjraQctiEm+D3sglcw2jj0UDz2n", + "7p65UXemNFvuO5wcHnKqjORGyQ5TFY+47K3oSx4Y8JYU1yzjJLI7eWX3ToC1TlDDz29eenlgozR0dauL", + "EFPUkSw0WC3gGkMv0rhxY94SBbqctPm3gf7T2tCDcBgJUOHEpkR1CjQfbof3X2+WPfboVerqCqAScnVO", + "/tsoTNOofTF6oWQ9orGslJOdBC8ZNmIV37tdbkTQA77hSwCT5aosIU++UXvRV645q7igYxNn2AyOjwfm", + "WoEEI8zIdX55+X61di8U99ndxJGWhQICyOfO3P8RDYCPRNivQDq4Xzw7BvVg4K5bBYU6HdXhdPzBfvZ9", + "3GA+fW+G847vsmvn4H0d0v0SnK79/W+tj2HQI4Ttvzb8u09dU5X/YaCMjsZYOKqteRliO5G6l6B9bZcO", + "OKiDweobAMwIeXXUN/9ouoo3vu24U/3l5XstC4e5pz58jnykunZsQuaWo10CZNFCn6+5GPFJNQDpCd0H", + "N+Nbpa0gpx2AT+zAZzXPr5IKyHfui2mc+MjTPnLnM5MDudAa8dr1eRdmSxljxQaM5ZsquXfWuJ2juwDv", + "Fbd9TRfHMA3kShbGUVAODCpl1scyCpj0VDuJk5XCkKwTc+Zcaco+i7KrVb1o76lbcjCuvQtjppWyY4A6", + "ODsJCZSyjNd27a6wEEcAWCugvxKKfsN3q4yCntgrJ2WEvL28LPdzJuwXNI72np2cbUBflcCsBmDbtTLA", + "SuDX0NZbwdG+MOzdThQGq6mUsBO5WmlerUXOlC5AUyEe1xzf0tTJz/fojPmoXh8H8W4ncXlNcYN4nbTM", + "EL3SWLTiFc9JhOv/jGUwDJTXYM7Yu60iIEyb28A46bdbo6K2FDNYiOUSkHvgcvApjv3aDxFMWDkGQw2a", + "Yf2a7p8HDCgsM2v++Jtvxwjt8Tffpmjt7Y9PHn/zrZOEuWS83olScL2Pm7lWc7aoRWl9om3OriG3Ssca", + "ByGNBV4MaIu0UX4WlGWWtcy9G1rTJa7v8/bHJ9989fj/PP7mW6++imYJUdA+wA7ktdBKuk9BYdhQiJ+y", + "mQ12wthPIC3ZnczwvZy61R1qckTLTj6lRswHXnTNuT0WtiH9VDj4JRQr0PP2InZ8tc054h53SkcS8BIo", + "RMzdi0JarYo6B8p08bbDNyKwxACkpnxC5G6DZz0UWGrhDJrURmZh7AW+gB/Rg0yq7grxjME1aIrpaQd6", + "QJdDBJexXKOfErot+aVC8TB9tdfVSvMCpnkh4GX1M/VoEjeEEa7VaQP84tr3H1idN0BHsk4LsFEgB2DR", + "m/bOTd05B7jE6PvtzVgE5XMqWqShpFA3rIxCNXsGr7MlQOYEwSTFu1cTJuDKc6gcpcdFOgHcXUMnHc8y", + "Fg8MQlsTBE1BeGkNFsKU5bzM65KeEgdEyG3OS7QEtYRdwtIqR3txEbLWFCDcXAv0EKeSIjSfdndY1APT", + "Rl2D3vsWpHkJFTzcudE9152hqJyVcA1lEnDgGmWHH9WWbbjcN7hwU7RgzKPIuAZyEoLRQ4Sw/bNXCkXg", + "0znzBHkYSIeKkc0tYjxXoIUqRM6E/Bf4gx4/HZBiqBSQklbIGutiaWjhpqueYYhuPwx3SAE66VLs4OIW", + "HGBtFIeEbQfbRfRQ6AZDGMuvgMAOwcReupmKUw1GFHUasqXmeRey04jRH9433MK5blBr7ogue8yrOeSH", + "Dl2flntk08PWcJdG+VSHL09hVryJ+GKehyecxX0GqtByRGOgrMJLO8rd0ox9Ddp03ZAjMwHsjoztWnTG", + "p7xcIbXB6bNkwR/NjM63J3bc0lyQnynwHvv7tAqpHRxJWtYAYLbC5ussFTjiAaAWDoY3/Sf8cEqSLvAU", + "wnIJuZ0CA0btUEWsUSjos4PiGfACI8bbqCuKt+qD8uAnxdzQJhJ5pBH4kGglHhzl4QkJzRsKOUb8v6iJ", + "tO8D7tETYsIxCDKOx31yy3wbTzwvmqh3zvZgcFca7/LojGBmkrSJN0xaQMn3h6bEBt1JG5k3GLfpzsEE", + "Hu5CIW/20SDkMLU/Z4cmd036C26O5/BUxKV2BphUCSe3kEuzCaHyWQkTPptJG5YjZr5BMg6VfJuSim2t", + "xHs2Kt5NWox0XGMIPhlsA34J+4B/9DfiE1tXQgVif0/SSn5NE0qUVDZJMkXzPQqJpjgDXH9Ivsd9gd2J", + "1NSzZAWK+gz2LbVPP1zzciTQ8g1UGgzqCTh798OTl94pZizcMk9HOl5evufW0RT2Y6PJpj7MZyOZIS4v", + "3y+QY1LehwYbQ+ti0ofaMSLhurvPg943c8kbS6IabWjwxR8C9LcQAMYqLryjVxtrOtxZH3Q8jO6eEkTW", + "Iri/CB/VO3qEfuRm/ZznVun9MIOre1qPpNa5vHzv8H3KFn/1bZrdOxDSk7yL8vd0VWSN/x/63gV5SC0H", + "eXwYJvJZc685C3+6l36UtKf5PpvPBnqAFhdxHuKEn9EaP1NuQxYquQ0xPZquuVhkTdhIqqLjfObTLcc5", + "Zo+GggmTbcRKo8iTHnU8TXR0RSVuGBK1ExWjvVgzLov3iLSz8B7ELXjRjeBnThH0C1nADnRrmXnVrq5n", + "KSf1ERYGNlmrTE3zJiL2+5UPKA7fTWEsFAe0NcsTjyJ5/JROTJs0fnmz8WWGYrLMtiBW6/TGvr7R0E6M", + "Po606/tHWorBvUKt/xN3IJEiRxjtsmXDB5OhRxwbfQPsiP3ermn5n0tIqgb3hqlGwLXFiYTwXyOb3a8s", + "lGDURmyqkpw/PSsZ5L46KdFEG2Dy8eOV7jro46OHb8CNPRLvPmrjprAcT0l1OFbj7/Kp2lQljAvPFZck", + "Pi+F9O/27ZrbuJh6sAGpPK91a8TtR2P8wktBVX4NZjGUSlWYtrCyQrr/YAIHVVv6P3Dt/kNORd3/EVVF", + "cpIbaoZ4weRXYaAQyTmbz6jzLFB2UopKOiYNNqWbzirgE52w0ZYmAQoMSGizSZ/z3JL90ztrSrBbpa8S", + "z5iFQX1Sx68qLvs65KZc27ri9EThjQeFT+HaZIVrQPOQmdqQd03Hf+Ior4Rd5WjtdAALvbmeCGGzeUpe", + "g/a2D+VzSpKVg9LUDhI2MQ/eKWtKseobJgCa5IYyfKEltrkVEkk1mPZtQrWWjt/Jka/Q0GUz1/vKqnNs", + "g03OjdV1bg15bbZzDqjSbTQ5Lx2vn9cXKZwkoIwge6ZVmYZr4GNqenTVgt9qcEhGU51rzJoBUoidyrT7", + "e0xjp7cWAYldYShoihzsyn1Ilsndnm949Z5m+ZVl7A1B3JRSQI+8jVlVp3tu0VAp0A0vbTb6yvHyJXvL", + "SxuLEQ4g7+fReMiMJ64lCTY5ev4pnhwOppuToFswFIfE/e0NxP1R3oHzNhcFSWDdI3UNmmKhJ5PDL6HH", + "h/nsXtfxpjmxQ64QrW/aKuJNiVhDWsUSvobj1KZK5rJg0fyG4dlI+Ari0QVp9f4maYbEKjOlOmF5b8Xq", + "retwZEtDs8GelmoLOnPzHkBxGUyNFG9DLTuppJtaLjQeeUpAwdxizM02ggY+aSd8l+N70Y7dc0rhZa5k", + "1pn9frkO8csMqStrshwc2T2+6e5eFd7Wp3ItZBJ7IVfpzI+O0V/B/vPQJSQ8jgf4RBPvuDIHHxo/NQ4N", + "kZFp643IZCTsCjpHqki45xpKmr5czoFzZbvnqvUv2ohcK47OGG3KaRhIsP6xh76MzW4ccjBJK5cpMTd1", + "frevoHHKHZba2fAqvLfwHe6E4LOPqbRibxp35KFHaa6k5QIL6iSFe3LGhbJCRtXqxs8+K/L9JbqZe74m", + "h/cn3yABRYar2H/b/X+4ZVYD3L+H6xXss1IswYoRg3S5dCv5G+xZaHZ2ZzLFWI6kjsEPNQ8lxQS0eZ+Y", + "0vRlhV/i9FKM+CgGSZvwl2EFWNAbR4prtWWbOl+j7M5XEBIsocEGPct7E3VGDxkpuunBfHygqXhOA1HY", + "f8n1CjTzkfhNXZJgANpwgeek9Qbux+eioxhPGeOOpX16RakAIt6FptMoB1Qiu1QA4wr252QZxN9vwEjG", + "U0mNAIZ5pT4iSLdKTxXnNDtCr1cdoyoV++okf2vAv0PjqoPPqxBONK4Os7VNXR6uA49DbWC4zunROPHe", + "Jp647dqmegYMN3fEoH/Mjj9SssWbe5GPY1+G8LF/fvVPpmEJGvVWX36Jw3/55dz7K/zzcfezo7Yvv0w7", + "NSVPzt35DTSVANwYfrokdXQLwPZsqHTJGwqnJcc1d6EpiS6bZdkLeZIFw2QDKJ5wjACBUlWQbI3FyuIb", + "FBPAaVjVJadQHyEl6E6nKZl+6Plvd9KruvDPdzuZahuLk9g62o5UgdCoCvPNKuf2yslRnqUcMxrddMQ2", + "J1I7ImVXuc2IzymlSzNiiDC9zZjv/BhHSjheXr43K4lquaCMEyFLAArAhOEuNTWZA0KZx5CpqAlng99q", + "XvpwPYnBce8wbU9+BZIqODou56vvMpCm1l4l6GDF8RwofhgVX+ambXLTWo7jBcEuL9/rnLS/3qPdJ4PA", + "zFPU1YkZhUOOOlxUxbV3T8yxZHROsuVuLt8wxBejr+ixpxeSsd6M2/B72aLjyBLMuBj6jwzf1i9pS6Gn", + "cxG2SSV7NzPlv3/w4tlDJvrF0OOsj9FD6/iy4xIq0yCiDCMDWPq5J0+BYgkwFs7TCyxkSxhRBR8s3+HG", + "wlch1fHAVn0X7KNQTsyq8CM3WKXDN28j6T/HVAodINmLZ0k5o5Md9+SSEPPZSqs6Hbm90mga6vuCukcA", + "Clj0gCfnsvPH33zLCrECY8/YPzC5Hl2+w7poXWwy0dZb65TyZAhYk6CVxCAfjBjNufYIHQQHCx+UiMPc", + "P4Zvkp98PkO5JLO7VID7i4HMwiofwYm5RSN+03F7v4uwdiGt5sR8M7VcJvPt/h1/b90idODJGoZYn8CV", + "r2Cv4aayy9+wc1NidJzzlMh5sNbOzRhPCXwkcqDcJY7P14+z9gSdsZeuNwO5VNq9qjc1Wvpgh4n5vMEt", + "llIxfZ1ty0Nj5jr5O2iFSgPJlDds989Ys9kYZclzlOeNjyJ2MDSJdRvF5IO3KM3MCciH9CYdHjVWSytI", + "/HHb+Eu0i5W7eBzQ/1iLMkEFlXLfTQzHnEnFFDoHxS0prUGbdZFg9mHhHUK632MepxMv0qZ+RwkYD/ky", + "qq3RaiTyNZdtxfbjJRmGNDmtJvOgKFHimKcrRrgFrGgBqzuB89M66kk1Eh7qPqAYooEyJDbas3tOBsT3", + "G5D2hpzvNfUm3wSsZ6sPvwD0yAsg9D5WB/gK9plV6bGBDEskmTdPLdSTEreN1jgfefc0MXahBn4ru9IJ", + "ciLCskaDbmS6DHpS/6Rr/MmuYN96u8S1AunZdINXFl2LaS34O7GB9l1CglxKBBKTrkR6XqbftZQTiVj2", + "FweW0wxzmCrMCFVQ38M0MdnOG5FtZOgd5Dm6wSmI3JAwF8eBMI99Bd3APnRMbBR1nSQXqDM4Y8+aJDHo", + "h0ix9m3mGNJn9b0VKSNKkyVZ6KD34jroq9GhEZ3d8NQkGIFvQLKRazOUknwTni+xwZgiKDTbLUG37VLK", + "mNByqX9vGw71QKFZVaFnwYhGy7cytkLj0BimW6fMiu9nQRiczWduWe4fB7b7d6l/d/9UVYlVTqvl0Ccz", + "fYA9TWQ4TyLEfdZ9tXYEyeYktqR1RAN6sI6eD9xdUg3e5lY9VT0ZK9ApHXn7w1Nelu920vsBDsPeDnhe", + "8opC3156j8uGQzs27t13g9bKc4fYEsPz3Il4RZvyIYLzC8P6dVMoEcSwcsoBb8yjHLovAsS0yfVqdN2o", + "sBqKoSJnXK9qSj90D+s7soKRlw2vROETMg4L2XmRjdhCraFgSvtUXmLp87SNVXI4XqaKdq/yMqPIW9Gw", + "zUIxQulz9/iByidbVzLLG89yd0+6F6ZV7JI8si9nZ+wF5YzRwAtisFpYSNVR6qwfk99uAcs6B4rOGuxG", + "VfDO3Cnq1NwySNka0H8iUSLt37IeF2LM1CMYG+NKJFV1kfQJMPR0WEwMiwVIZf+N8DSpMtfl5Xuo8GB1", + "y17EcRRV1RTrKsHt+281BsA5ho3DjuholQaxkiO12JFAljxcBKaPruR10OVSPt1gjHgzuCUacfxmTBQt", + "LzQYpRDgRYal7A+4fCfYa7MXI8XhicE1ySZNG3tj/CqjGhjTlhjYzOtohUjYQZS9y/XdoKTareuo9Qbo", + "cI1jfTsBRonKa/Fd2B/6mGQWWTkPSmZUsqF0Cyf+pCEL92fgWLKgag51G690KZ+w30Er/1hthnIHotWN", + "+zTgPj/qWaJTU1jFDLr1pzyxYA0t/oB0OFoA6vLy/Y4PpAyE6Rbyxc1qeB3F8fORUiIxjoOpzNcQuWUl", + "IJrxwMa2MZdDixgvcF+j+guxjxcxmaagAO22r6mCxMK3I2VMDmJzeRCbB8bvZGDahtchpR9Os0//mqRc", + "V9uw49QjFdc5HqPYVpQaTj3l8DfOA5NII7yQb0scYdYD5DFuSuecvESfkBHdvcqMF7wCfGfMs5B0Im8D", + "5TJws2CbC9bjmNLczUT32oZXd1o97ijziCAe9zmAUY+DNq+Zv5gTqcxphNa3wcmawRqZEBlPXHsYPY1C", + "/NpPZ8XjqhBmreqyoMIQG8zF1r4xE9jxBaAaubAtyEVuHOh1EQdZm2iGeLMZe+FG5uWW701Q1LaUNT5c", + "2FUqH5FQEsbJGkm7nN4bnZObOOSiEiBt43MT48UR+bh6Mz2wV5M6rkNZ5MR1o7Xwjve8raTWNb0Fy5uv", + "FsWjG3rut5mXXXUBDRxU0a7N0zB2WFGD0uhCO55SJFVPr9nSI0zP20YPcjuvVzyVyVEv4nI0zTh7k0p2", + "A4BHjDLSNXJIe8X1VecS9IfVDyBXlE6gM2pHxoiSABgoKRVpLwZ5LELGQOlNGa/rRSlyNCOg03djWPAe", + "/wV7w2WhNux5SObz4Jc3zx8yDaYubSCykNnYEZ+H5NOWExhdeKWXfuVvo2iZZvlCeovKShirE4rLe18V", + "5nw85nDkGi2Nbb2OyGBN6R4HAeHCc8H0NYQTXsE+K0RZjxKya3VVdBNumnqBZeGEpKy8C25z9GYZgGAO", + "TH3Ew8G1KWmp6OZw25VOOzC4XH9iOrNUvfPzuRHQkadEMK8e5p7ecnMq+/TdiH/6mW4mH5J42IZJRImA", + "HT5DQZTexX8rKSuaguK0nPRhfFXCVtjqupS2RT9l4xkaGRKOupx2x0u7nQY5CyfBwmdiKHG5CfH293dL", + "Kxlh/8IXKy0j4WdZy8L0trAth3/A/npQ9vGiT2hz0JQ7JhRMlQQ6QbNdSNBw6YNO2nhpY1QuWiM81pqk", + "qpJ/l+XeJ6XrV/Rot7LS6loUqUL0pVqJ3JAK5lSL8cvQ98N8tqlLK244zqvQl0zY6etQrPxVKAuuCwbF", + "42+++eqv3VQInxG7Gm5S0r3HL8trGbkVeVeObVY3gYkFVJ6t1JBljRrb9Kq1PTTGtVTi1uk2MgRkPPQ9", + "KFq9g8hiz3hE6sqJ7aUV7U9z99uam3XLOqOyxVhGmjPPr/pefxhfFBn67jn83BN2divHjN7xGGMc7SH5", + "HM5GzB6JHqayxFcRJxmscOOXSHpXRy8h6BL3uirByXYtDxxNoxNQQ1d+mPOtGFb5j8dL7zo2wNKBykki", + "lJfVCZOtxIUKghaqG3gHD/bnbQxXKi/eWoNxEKW9b9Y6mWnkUP7NNvNhIq/6Sbh929vTXmYS3LdRCbe6", + "+kQJbA7RwOeRxSHtiHVYZB7LxcCmBOY1yaj6SajGpecoK+wh0h/Nt9p9P0/PaOLB6Xu5jbmnmSo4qL2L", + "QkfjDF3sBZF/69WIcqykfDU+5R4Zf30BgO5+3T4k/wNGCCwVZTeQlue2TS0+e+JHmvkiv7O1tZW5OD/f", + "brdnYZqzXG3OVxjllFlV5+vzMBCmkeykTvNdfPUrd+2Weytyw568foFCsrAlYMAEoi5KqHsxe3z2iFIv", + "guSVmF3Mvj57dPYVHZE10sU5pTl2/11RmIOjGpSEXxQYgn4FcaJkrJ2NqZCx++NHj8I2+GdiZJ48/5ch", + "hjbNYhpPg5vc3YgHaE97GBXkT1RQlldSbSX7QWtFDNLUmw3Xe4yAtrWWhj1+9IiJpU/vTIk/uBPT3s8o", + "Inf2q+t3fv34PPIT6/1y/kdw0RDFhyOfz3lVmSwyIB9tH6zwB1slovim95k0Q68AZWibni/69fyPron6", + "w8Rm5wusFDG1KUyd/tz7+Ye2/cXj3+d/BNXyhwOfzn1aikPdR/aNqs2c/0Hu06SqiKZKd+qw/T/szkOH", + "Gl3tjvns4v0fPT4DO76pSkAWM/vwa0PeDYfyZP5h3vxSKnVVV/EvBrjO19h9lyktVkI68t3y1Qp01mMw", + "/y8AAP//tVra42nhAAA=", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/indexer.oas2.json b/api/indexer.oas2.json index 2a781fd85..71a2f94f7 100644 --- a/api/indexer.oas2.json +++ b/api/indexer.oas2.json @@ -2864,9 +2864,10 @@ }, "group-id": { "type": "string", - "description": "Lookup transactions by group ID.", + "description": "Lookup transactions by group ID. This field must be base64-encoded, and afterwards, base64 characters like +, / and = must be URL-encoded", "name": "group-id", - "in": "query" + "in": "query", + "x-algorand-format": "base64" }, "txid": { "type": "string", diff --git a/api/indexer.oas3.yml b/api/indexer.oas3.yml index e27f42c64..63382e00a 100644 --- a/api/indexer.oas3.yml +++ b/api/indexer.oas3.yml @@ -136,12 +136,14 @@ } }, "group-id": { - "description": "Lookup transactions by group ID.", + "description": "Lookup transactions by group ID. This field must be base64-encoded, and afterwards, base64 characters like +, / and = must be URL-encoded", "in": "query", "name": "group-id", "schema": { - "type": "string" - } + "type": "string", + "x-algorand-format": "base64" + }, + "x-algorand-format": "base64" }, "header-only": { "description": "Header only flag. When this is set to true, returned block does not contain the transactions", @@ -4916,12 +4918,14 @@ } }, { - "description": "Lookup transactions by group ID.", + "description": "Lookup transactions by group ID. This field must be base64-encoded, and afterwards, base64 characters like +, / and = must be URL-encoded", "in": "query", "name": "group-id", "schema": { - "type": "string" - } + "type": "string", + "x-algorand-format": "base64" + }, + "x-algorand-format": "base64" }, { "description": "Lookup the specific transaction by ID.", From 46359c2e75a54b2cddf33517e869f19b7c8ea5d0 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Mon, 9 Sep 2024 17:34:28 -0300 Subject: [PATCH 8/9] Optimize timestamp filters for transactions --- idb/postgres/postgres.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go index 6d904b29b..579259fda 100644 --- a/idb/postgres/postgres.go +++ b/idb/postgres/postgres.go @@ -576,13 +576,13 @@ func buildTransactionQuery(tf idb.TransactionFilter) (query string, whereArgs [] } if !tf.BeforeTime.IsZero() { convertedTime := tf.BeforeTime.In(time.UTC) - whereParts = append(whereParts, fmt.Sprintf("h.realtime < $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("t.round <= (SELECT bh.round FROM block_header bh WHERE bh.realtime < $%d ORDER BY bh.realtime DESC, bh.round DESC LIMIT 1)", partNumber)) whereArgs = append(whereArgs, convertedTime) partNumber++ } if !tf.AfterTime.IsZero() { convertedTime := tf.AfterTime.In(time.UTC) - whereParts = append(whereParts, fmt.Sprintf("h.realtime > $%d", partNumber)) + whereParts = append(whereParts, fmt.Sprintf("t.round >= (SELECT bh.round FROM block_header bh WHERE bh.realtime > $%d ORDER BY bh.realtime ASC, bh.round ASC LIMIT 1)", partNumber)) whereArgs = append(whereArgs, convertedTime) partNumber++ } From cdb6d80761ff9a1274f278e13e2792816b1731d3 Mon Sep 17 00:00:00 2001 From: Agustin Godnic Date: Mon, 16 Sep 2024 19:25:00 -0300 Subject: [PATCH 9/9] Update codegen --- api/generated/v2/routes.go | 1399 +++++++++++++++++++++++++++++++++++- api/generated/v2/types.go | 2 +- 2 files changed, 1394 insertions(+), 7 deletions(-) diff --git a/api/generated/v2/routes.go b/api/generated/v2/routes.go index f1d6ccc15..67a7e76c7 100644 --- a/api/generated/v2/routes.go +++ b/api/generated/v2/routes.go @@ -8,21 +8,1162 @@ import ( "compress/gzip" "encoding/base64" "fmt" + "net/http" "net/url" "path" "strings" + "github.com/algorand/oapi-codegen/pkg/runtime" "github.com/getkin/kin-openapi/openapi3" "github.com/labstack/echo/v4" ) // ServerInterface represents all server handlers. type ServerInterface interface { + + // (GET /v2/accounts) + SearchForAccounts(ctx echo.Context, params SearchForAccountsParams) error + + // (GET /v2/accounts/{account-id}) + LookupAccountByID(ctx echo.Context, accountId string, params LookupAccountByIDParams) error + + // (GET /v2/accounts/{account-id}/apps-local-state) + LookupAccountAppLocalStates(ctx echo.Context, accountId string, params LookupAccountAppLocalStatesParams) error + + // (GET /v2/accounts/{account-id}/assets) + LookupAccountAssets(ctx echo.Context, accountId string, params LookupAccountAssetsParams) error + + // (GET /v2/accounts/{account-id}/created-applications) + LookupAccountCreatedApplications(ctx echo.Context, accountId string, params LookupAccountCreatedApplicationsParams) error + + // (GET /v2/accounts/{account-id}/created-assets) + LookupAccountCreatedAssets(ctx echo.Context, accountId string, params LookupAccountCreatedAssetsParams) error + + // (GET /v2/accounts/{account-id}/transactions) + LookupAccountTransactions(ctx echo.Context, accountId string, params LookupAccountTransactionsParams) error + + // (GET /v2/applications) + SearchForApplications(ctx echo.Context, params SearchForApplicationsParams) error + + // (GET /v2/applications/{application-id}) + LookupApplicationByID(ctx echo.Context, applicationId uint64, params LookupApplicationByIDParams) error + // Get box information for a given application. + // (GET /v2/applications/{application-id}/box) + LookupApplicationBoxByIDAndName(ctx echo.Context, applicationId uint64, params LookupApplicationBoxByIDAndNameParams) error + // Get box names for a given application. + // (GET /v2/applications/{application-id}/boxes) + SearchForApplicationBoxes(ctx echo.Context, applicationId uint64, params SearchForApplicationBoxesParams) error + + // (GET /v2/applications/{application-id}/logs) + LookupApplicationLogsByID(ctx echo.Context, applicationId uint64, params LookupApplicationLogsByIDParams) error + + // (GET /v2/assets) + SearchForAssets(ctx echo.Context, params SearchForAssetsParams) error + + // (GET /v2/assets/{asset-id}) + LookupAssetByID(ctx echo.Context, assetId uint64, params LookupAssetByIDParams) error + + // (GET /v2/assets/{asset-id}/balances) + LookupAssetBalances(ctx echo.Context, assetId uint64, params LookupAssetBalancesParams) error + + // (GET /v2/assets/{asset-id}/transactions) + LookupAssetTransactions(ctx echo.Context, assetId uint64, params LookupAssetTransactionsParams) error + + // (GET /v2/blocks/{round-number}) + LookupBlock(ctx echo.Context, roundNumber uint64, params LookupBlockParams) error + + // (GET /v2/transactions) + SearchForTransactions(ctx echo.Context, params SearchForTransactionsParams) error + + // (GET /v2/transactions/{txid}) + LookupTransaction(ctx echo.Context, txid string) error +} + +// ServerInterfaceWrapper converts echo contexts to parameters. +type ServerInterfaceWrapper struct { + Handler ServerInterface +} + +// SearchForAccounts converts echo context to params. +func (w *ServerInterfaceWrapper) SearchForAccounts(ctx echo.Context) error { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params SearchForAccountsParams + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "currency-greater-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "exclude" ------------- + + err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), ¶ms.Exclude) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err)) + } + + // ------------- Optional query parameter "currency-less-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) + } + + // ------------- Optional query parameter "auth-addr" ------------- + + err = runtime.BindQueryParameter("form", true, false, "auth-addr", ctx.QueryParams(), ¶ms.AuthAddr) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter auth-addr: %s", err)) + } + + // ------------- Optional query parameter "round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) + } + + // ------------- Optional query parameter "application-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.SearchForAccounts(ctx, params) + return err +} + +// LookupAccountByID converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountByID(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountByIDParams + // ------------- Optional query parameter "round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "exclude" ------------- + + err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), ¶ms.Exclude) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountByID(ctx, accountId, params) + return err +} + +// LookupAccountAppLocalStates converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountAppLocalStates(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountAppLocalStatesParams + // ------------- Optional query parameter "application-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountAppLocalStates(ctx, accountId, params) + return err +} + +// LookupAccountAssets converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountAssets(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountAssetsParams + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountAssets(ctx, accountId, params) + return err +} + +// LookupAccountCreatedApplications converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountCreatedApplications(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountCreatedApplicationsParams + // ------------- Optional query parameter "application-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountCreatedApplications(ctx, accountId, params) + return err +} + +// LookupAccountCreatedAssets converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountCreatedAssets(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountCreatedAssetsParams + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountCreatedAssets(ctx, accountId, params) + return err +} + +// LookupAccountTransactions converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAccountTransactions(ctx echo.Context) error { + var err error + // ------------- Path parameter "account-id" ------------- + var accountId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "account-id", runtime.ParamLocationPath, ctx.Param("account-id"), &accountId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAccountTransactionsParams + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "note-prefix" ------------- + + err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) + } + + // ------------- Optional query parameter "tx-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) + } + + // ------------- Optional query parameter "sig-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) + } + + // ------------- Optional query parameter "txid" ------------- + + err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) + } + + // ------------- Optional query parameter "round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) + } + + // ------------- Optional query parameter "min-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) + } + + // ------------- Optional query parameter "max-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) + } + + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // ------------- Optional query parameter "before-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) + } + + // ------------- Optional query parameter "after-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) + } + + // ------------- Optional query parameter "currency-greater-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) + } + + // ------------- Optional query parameter "currency-less-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) + } + + // ------------- Optional query parameter "rekey-to" ------------- + + err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAccountTransactions(ctx, accountId, params) + return err +} + +// SearchForApplications converts echo context to params. +func (w *ServerInterfaceWrapper) SearchForApplications(ctx echo.Context) error { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params SearchForApplicationsParams + // ------------- Optional query parameter "application-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // ------------- Optional query parameter "creator" ------------- + + err = runtime.BindQueryParameter("form", true, false, "creator", ctx.QueryParams(), ¶ms.Creator) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter creator: %s", err)) + } + + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.SearchForApplications(ctx, params) + return err +} + +// LookupApplicationByID converts echo context to params. +func (w *ServerInterfaceWrapper) LookupApplicationByID(ctx echo.Context) error { + var err error + // ------------- Path parameter "application-id" ------------- + var applicationId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupApplicationByIDParams + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupApplicationByID(ctx, applicationId, params) + return err +} + +// LookupApplicationBoxByIDAndName converts echo context to params. +func (w *ServerInterfaceWrapper) LookupApplicationBoxByIDAndName(ctx echo.Context) error { + var err error + // ------------- Path parameter "application-id" ------------- + var applicationId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupApplicationBoxByIDAndNameParams + // ------------- Required query parameter "name" ------------- + + err = runtime.BindQueryParameter("form", true, true, "name", ctx.QueryParams(), ¶ms.Name) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupApplicationBoxByIDAndName(ctx, applicationId, params) + return err +} + +// SearchForApplicationBoxes converts echo context to params. +func (w *ServerInterfaceWrapper) SearchForApplicationBoxes(ctx echo.Context) error { + var err error + // ------------- Path parameter "application-id" ------------- + var applicationId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params SearchForApplicationBoxesParams + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.SearchForApplicationBoxes(ctx, applicationId, params) + return err +} + +// LookupApplicationLogsByID converts echo context to params. +func (w *ServerInterfaceWrapper) LookupApplicationLogsByID(ctx echo.Context) error { + var err error + // ------------- Path parameter "application-id" ------------- + var applicationId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "application-id", runtime.ParamLocationPath, ctx.Param("application-id"), &applicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupApplicationLogsByIDParams + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "txid" ------------- + + err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) + } + + // ------------- Optional query parameter "min-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) + } + + // ------------- Optional query parameter "max-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) + } + + // ------------- Optional query parameter "sender-address" ------------- + + err = runtime.BindQueryParameter("form", true, false, "sender-address", ctx.QueryParams(), ¶ms.SenderAddress) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sender-address: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupApplicationLogsByID(ctx, applicationId, params) + return err } -// ServerInterfaceWrapper converts echo contexts to parameters. -type ServerInterfaceWrapper struct { - Handler ServerInterface +// SearchForAssets converts echo context to params. +func (w *ServerInterfaceWrapper) SearchForAssets(ctx echo.Context) error { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params SearchForAssetsParams + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "creator" ------------- + + err = runtime.BindQueryParameter("form", true, false, "creator", ctx.QueryParams(), ¶ms.Creator) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter creator: %s", err)) + } + + // ------------- Optional query parameter "name" ------------- + + err = runtime.BindQueryParameter("form", true, false, "name", ctx.QueryParams(), ¶ms.Name) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err)) + } + + // ------------- Optional query parameter "unit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "unit", ctx.QueryParams(), ¶ms.Unit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter unit: %s", err)) + } + + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.SearchForAssets(ctx, params) + return err +} + +// LookupAssetByID converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAssetByID(ctx echo.Context) error { + var err error + // ------------- Path parameter "asset-id" ------------- + var assetId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAssetByIDParams + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAssetByID(ctx, assetId, params) + return err +} + +// LookupAssetBalances converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAssetBalances(ctx echo.Context) error { + var err error + // ------------- Path parameter "asset-id" ------------- + var assetId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAssetBalancesParams + // ------------- Optional query parameter "include-all" ------------- + + err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), ¶ms.IncludeAll) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err)) + } + + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "currency-greater-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) + } + + // ------------- Optional query parameter "currency-less-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAssetBalances(ctx, assetId, params) + return err +} + +// LookupAssetTransactions converts echo context to params. +func (w *ServerInterfaceWrapper) LookupAssetTransactions(ctx echo.Context) error { + var err error + // ------------- Path parameter "asset-id" ------------- + var assetId uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "asset-id", runtime.ParamLocationPath, ctx.Param("asset-id"), &assetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupAssetTransactionsParams + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "note-prefix" ------------- + + err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) + } + + // ------------- Optional query parameter "tx-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) + } + + // ------------- Optional query parameter "sig-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) + } + + // ------------- Optional query parameter "txid" ------------- + + err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) + } + + // ------------- Optional query parameter "round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) + } + + // ------------- Optional query parameter "min-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) + } + + // ------------- Optional query parameter "max-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) + } + + // ------------- Optional query parameter "before-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) + } + + // ------------- Optional query parameter "after-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) + } + + // ------------- Optional query parameter "currency-greater-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) + } + + // ------------- Optional query parameter "currency-less-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) + } + + // ------------- Optional query parameter "address" ------------- + + err = runtime.BindQueryParameter("form", true, false, "address", ctx.QueryParams(), ¶ms.Address) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address: %s", err)) + } + + // ------------- Optional query parameter "address-role" ------------- + + err = runtime.BindQueryParameter("form", true, false, "address-role", ctx.QueryParams(), ¶ms.AddressRole) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address-role: %s", err)) + } + + // ------------- Optional query parameter "exclude-close-to" ------------- + + err = runtime.BindQueryParameter("form", true, false, "exclude-close-to", ctx.QueryParams(), ¶ms.ExcludeCloseTo) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude-close-to: %s", err)) + } + + // ------------- Optional query parameter "rekey-to" ------------- + + err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupAssetTransactions(ctx, assetId, params) + return err +} + +// LookupBlock converts echo context to params. +func (w *ServerInterfaceWrapper) LookupBlock(ctx echo.Context) error { + var err error + // ------------- Path parameter "round-number" ------------- + var roundNumber uint64 + + err = runtime.BindStyledParameterWithLocation("simple", false, "round-number", runtime.ParamLocationPath, ctx.Param("round-number"), &roundNumber) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round-number: %s", err)) + } + + // Parameter object where we will unmarshal all parameters from the context + var params LookupBlockParams + // ------------- Optional query parameter "header-only" ------------- + + err = runtime.BindQueryParameter("form", true, false, "header-only", ctx.QueryParams(), ¶ms.HeaderOnly) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter header-only: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupBlock(ctx, roundNumber, params) + return err +} + +// SearchForTransactions converts echo context to params. +func (w *ServerInterfaceWrapper) SearchForTransactions(ctx echo.Context) error { + var err error + + // Parameter object where we will unmarshal all parameters from the context + var params SearchForTransactionsParams + // ------------- Optional query parameter "limit" ------------- + + err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), ¶ms.Limit) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err)) + } + + // ------------- Optional query parameter "next" ------------- + + err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), ¶ms.Next) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err)) + } + + // ------------- Optional query parameter "note-prefix" ------------- + + err = runtime.BindQueryParameter("form", true, false, "note-prefix", ctx.QueryParams(), ¶ms.NotePrefix) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter note-prefix: %s", err)) + } + + // ------------- Optional query parameter "tx-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "tx-type", ctx.QueryParams(), ¶ms.TxType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tx-type: %s", err)) + } + + // ------------- Optional query parameter "sig-type" ------------- + + err = runtime.BindQueryParameter("form", true, false, "sig-type", ctx.QueryParams(), ¶ms.SigType) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sig-type: %s", err)) + } + + // ------------- Optional query parameter "group-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "group-id", ctx.QueryParams(), ¶ms.GroupId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter group-id: %s", err)) + } + + // ------------- Optional query parameter "txid" ------------- + + err = runtime.BindQueryParameter("form", true, false, "txid", ctx.QueryParams(), ¶ms.Txid) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) + } + + // ------------- Optional query parameter "round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), ¶ms.Round) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err)) + } + + // ------------- Optional query parameter "min-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "min-round", ctx.QueryParams(), ¶ms.MinRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min-round: %s", err)) + } + + // ------------- Optional query parameter "max-round" ------------- + + err = runtime.BindQueryParameter("form", true, false, "max-round", ctx.QueryParams(), ¶ms.MaxRound) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max-round: %s", err)) + } + + // ------------- Optional query parameter "asset-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), ¶ms.AssetId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err)) + } + + // ------------- Optional query parameter "before-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "before-time", ctx.QueryParams(), ¶ms.BeforeTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter before-time: %s", err)) + } + + // ------------- Optional query parameter "after-time" ------------- + + err = runtime.BindQueryParameter("form", true, false, "after-time", ctx.QueryParams(), ¶ms.AfterTime) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after-time: %s", err)) + } + + // ------------- Optional query parameter "currency-greater-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-greater-than", ctx.QueryParams(), ¶ms.CurrencyGreaterThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-greater-than: %s", err)) + } + + // ------------- Optional query parameter "currency-less-than" ------------- + + err = runtime.BindQueryParameter("form", true, false, "currency-less-than", ctx.QueryParams(), ¶ms.CurrencyLessThan) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter currency-less-than: %s", err)) + } + + // ------------- Optional query parameter "address" ------------- + + err = runtime.BindQueryParameter("form", true, false, "address", ctx.QueryParams(), ¶ms.Address) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address: %s", err)) + } + + // ------------- Optional query parameter "address-role" ------------- + + err = runtime.BindQueryParameter("form", true, false, "address-role", ctx.QueryParams(), ¶ms.AddressRole) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter address-role: %s", err)) + } + + // ------------- Optional query parameter "exclude-close-to" ------------- + + err = runtime.BindQueryParameter("form", true, false, "exclude-close-to", ctx.QueryParams(), ¶ms.ExcludeCloseTo) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude-close-to: %s", err)) + } + + // ------------- Optional query parameter "rekey-to" ------------- + + err = runtime.BindQueryParameter("form", true, false, "rekey-to", ctx.QueryParams(), ¶ms.RekeyTo) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rekey-to: %s", err)) + } + + // ------------- Optional query parameter "application-id" ------------- + + err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), ¶ms.ApplicationId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.SearchForTransactions(ctx, params) + return err +} + +// LookupTransaction converts echo context to params. +func (w *ServerInterfaceWrapper) LookupTransaction(ctx echo.Context) error { + var err error + // ------------- Path parameter "txid" ------------- + var txid string + + err = runtime.BindStyledParameterWithLocation("simple", false, "txid", runtime.ParamLocationPath, ctx.Param("txid"), &txid) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter txid: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.LookupTransaction(ctx, txid) + return err } // This is a simple interface which specifies echo.Route addition functions which @@ -49,14 +1190,260 @@ func RegisterHandlers(router EchoRouter, si ServerInterface, m ...echo.Middlewar // can be served under a prefix. func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string, m ...echo.MiddlewareFunc) { + wrapper := ServerInterfaceWrapper{ + Handler: si, + } + + router.GET(baseURL+"/v2/accounts", wrapper.SearchForAccounts, m...) + router.GET(baseURL+"/v2/accounts/:account-id", wrapper.LookupAccountByID, m...) + router.GET(baseURL+"/v2/accounts/:account-id/apps-local-state", wrapper.LookupAccountAppLocalStates, m...) + router.GET(baseURL+"/v2/accounts/:account-id/assets", wrapper.LookupAccountAssets, m...) + router.GET(baseURL+"/v2/accounts/:account-id/created-applications", wrapper.LookupAccountCreatedApplications, m...) + router.GET(baseURL+"/v2/accounts/:account-id/created-assets", wrapper.LookupAccountCreatedAssets, m...) + router.GET(baseURL+"/v2/accounts/:account-id/transactions", wrapper.LookupAccountTransactions, m...) + router.GET(baseURL+"/v2/applications", wrapper.SearchForApplications, m...) + router.GET(baseURL+"/v2/applications/:application-id", wrapper.LookupApplicationByID, m...) + router.GET(baseURL+"/v2/applications/:application-id/box", wrapper.LookupApplicationBoxByIDAndName, m...) + router.GET(baseURL+"/v2/applications/:application-id/boxes", wrapper.SearchForApplicationBoxes, m...) + router.GET(baseURL+"/v2/applications/:application-id/logs", wrapper.LookupApplicationLogsByID, m...) + router.GET(baseURL+"/v2/assets", wrapper.SearchForAssets, m...) + router.GET(baseURL+"/v2/assets/:asset-id", wrapper.LookupAssetByID, m...) + router.GET(baseURL+"/v2/assets/:asset-id/balances", wrapper.LookupAssetBalances, m...) + router.GET(baseURL+"/v2/assets/:asset-id/transactions", wrapper.LookupAssetTransactions, m...) + router.GET(baseURL+"/v2/blocks/:round-number", wrapper.LookupBlock, m...) + router.GET(baseURL+"/v2/transactions", wrapper.SearchForTransactions, m...) + router.GET(baseURL+"/v2/transactions/:txid", wrapper.LookupTransaction, m...) + } // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/yTNMY7CMBBG4atYf21ZKbbyDZaCO0ycCRjsGcueIKQod0eE9r3i25F0YcS/afJIWpsK", - "iw3E/fDIsiqibKV4VB6DboyIf2mbOe5de3Sb0FzYmbqk8uJuLp/7DDWsNIz7u5bwoPQcKmEhoznLEi5D", - "5fq1PbSxUMuIgEcju4+fenwCAAD//zUNUoGeAAAA", + "H4sIAAAAAAAC/+x9a5PbNpboX0HpbpXtrNjtOI/a6arUlh/jG9fYmZTtZHbXnXsHIiEJaQpgALAlJdf/", + "/RbOAUCQBCWqX25P9MluEY8D4ODgvM8fk1yuKimYMHpy9sekooqumGEK/qJ5LmthMl7Yvwqmc8Urw6WY", + "nPlvRBvFxWIynXD7a0XNcjKdCLpiTRvbfzpR7LeaK1ZMzoyq2XSi8yVbUTuw2Va2tRvp48fphBaFYlr3", + "Z/27KLeEi7ysC0aMokLT3H7SZM3Nkpgl18R1JlwQKRiRc2KWrcZkzllZ6BMP9G81U9sIajf5MIjTySaj", + "5UIqKopsLtWKmsnZ5Knr93HvZzdDpmTJ+mt8LlczLphfEQsLCodDjCQFm0OjJTXEQmfX6RsaSTSjKl+S", + "uVR7lolAxGtlol5Nzj5MNBMFU3ByOeOX8N+5Yux3lhmqFsxMfpmmzm5umMoMXyWW9sqdnGK6Lo0m0BbW", + "uOCXTBDb64S8qbUhM0aoIG9fPidfffXVXwhuo2GFQ7jBVTWzx2sKp1BQw/znMYf69uVzmP+dW+DYVrSq", + "Sp5Tu+7k9XnafCevXgwtpj1IAiG5MGzBFG681ix9V5/aLzum8R33TVCbZWbRZvhg3Y3XJJdizhe1YoXF", + "xlozvJu6YqLgYkEu2HbwCMM0t3cDZ2wuFRuJpdj4RtE0nv+T4ulMbjKEqYc0ZCY3xH6zlHQhaZlRtYAV", + "kgdM5NKe49klLWv24IS8lIpwYfTUnTVzDbkwZ18++epr10TRNZltDeu1m3379dnT775zzSrFhaGzkrlt", + "7DXXRp0tWVlK18ERs/649sPZf/33/5ycnDwYOgz457AHKq+VYiLfZgvFKFCcJRX9PXzrMEgvZV0WZEkv", + "AV3oCp5O15fYvng9YDdPyBueK/m0XEhNqEO8gs1pXRriJya1KC2pt6O560u4JpWSl7xgxdSe2XrJ8yXJ", + "qdsQaEfWvCwt1taaFUMbkl7dHuoQOlm4rrQfsKD7uxnNuvbsBNsA/egv/68bRyWLgtufaEm4YStNdJ0v", + "CdUOqqUsC0T66AEgpcxpSQpqKNFGWsI6l8pxPEh1p65/w8SRHA6wILNtt6UoWqPv72P3h22qUtqVzWmp", + "WXq//OrjTYJVxrwFLcuJe7Eso+WmzMIPtKp0BivOtKGGxW2qyrYQUrAEAxJ+oErRrf1bm63lsoC0TprT", + "yfJSapYZuYcB8zwVbFjEMsU7dhA7Rt4vGYHJ7QdkRQGzhaXSZbklxh2ARQjima8p4XOylTVZw9Up+QX0", + "d6uxOL0i9vDhyFqcoqVmQ8jd24wEas+kLBkVgNoLJesqyWO8lvKirto8+WxLoAN59cIum2tcLlm5l3NG", + "Nfv26wweE3tNYY8tA7emqtBT953kS6poDjsNy/73KTmFtt+FkX56+9oPM7DSAPmhTAUCMfSiNl+XjBZM", + "ZVKU2/7ufA8fif1I5iVdnJB/LJmjc5YtsgeHJzUliplaCXsBS5lfkEIyTYQ0lqUylIuuNKMHFhzDs+dU", + "nUCV2Vs5zNqVnlphc8vFAdoUgeubkoKVDFC3IS3wqzZKbgGl7QWfElnZqyxr0yd5onDD4ucuBQRyMCi7", + "xSvZs+iSr7jpL/cN3fBVvSKiXs3sic0DG2ikOxq4woqRHG7irEXPK7pgmjDLJXIUPGEee8j2DBWj+XL4", + "rUGY9jwvK7rJlKxFMUK+MkSqmH/VFcv5nLOChFGGYGmm2QcPF4fB00h9ETh+kEFwwix7wBFskzhWS3Tt", + "Fzig6FRPyE+OI4CvRl4wERgHfAIZqRS75LLWodMQI2mn3s04CmlYVik255s+kO/cdli6j20c2+LJnCMB", + "rCCODtjhkKgOwhRNeFukT7ELtk0+pV0EwOUEBc7SfsG+u1cRZthzqUfiIXJOMf7txL1ReAeNMiQbCc7X", + "fnVEJa0sa/UfIY3Ec6OqJruW2gzH8EzL0FZ0Zro9CV3zRYYj9m4JX7y3HNacl8AT/Govhz/ZWtt3qX22", + "nh/TfCGoqRU7Oxdf2L9IRt4ZKgqqCvvLCn96U5eGv+ML+1OJP72WC56/44uhTfGwJtVo0G2F/9jx0moz", + "swnLTU3hP6dmqKhteMG2itk5aD6HfzZzQCQ6V78jRw1PoqnmQwDsYuuaDc1bqtTZ1jJ3A/sCQ+6ih0A7", + "dCWFZoC1T5GReOt+sz9ZkscEUPSIFzj9VUuQL5uxKyUrpgxnsera/vffFJtPzib/67RRdZ9iN33qJpwE", + "+dUMPWV4galxJAxJlyNqyAysqtrg056iDuE6fwiwdedsjkXOfmW5wQ1qg/GQrSqzfWQBdrDrm9st3ZLV", + "Ru5bV966xX3Exz2DR7o/8k/aycQVXXABC5+StWWzV/TCUgUqpFkyRexZMG38M4/kD1/+oHN3vIITo04m", + "qRuTOFN97UNtTu21ZXffAbt7E0fckagPOOsUSMeTDyff29ibRIHFDZ39TmPE+fkHWlW82Jyf/9KSuLgo", + "2CZ9Hrd62KVcZAU19Go4unhhuyYQ9D7jUNvQc1MIdLPIc8Ap3O2LelPbdcOX7Uo09khZE7fi+kRVa2ae", + "0ZKK/Eae05kbavQJv+GCAxDfo6rreMz+mMNW3sQRu929kYuMxojRV/h4uKk7HEw81z7amzrSUQd5xxIh", + "THkTm/SpEP+I8TeL8c9KmV9c6Sx3HRWMum9mubn5eeUmNeszuSFcoPbPcT7P5IbdV5FnZmEbfS2eyc0L", + "N6VUn7c0ggsfg8HPnMuQBvu3iHfWLvmvSkl1A6frZcMOPNPJimlNFyxte4nX6BuOWZQHGA6E2SWAhvp7", + "RkuzfL5kt3BRo7H3XNf3jTL2Bjb2Vkl2pDfet/5oVXuEvfawB1LZaBp933fv/pCL1paPJ4itM+2Sw/Fn", + "rA875I/e/hAbGBLejs6dPXqO7ElR5/GJ5sFzcS5esDkXYO0/OxeWDp3OqOa5Pq01U07APFlIckbckC+o", + "oediMu0+UEO2OvBOc9BU9azkOblg29QpoNtcYgRpaBk5MEQedM5s3Fgg+niGo2YWHWRtMuewmykGTjn9", + "2XQwWsPI6Mq3a9YpcWOjbd05BLvx07jfcwfrhyPs9JTjou3KZg/yB2mcBZquCSISqTXT5J8rWn3gwvxC", + "svP68eOvGHlaVY3m+5+N350FFGxfN6pGh8XCGWZsYxTNwKckjSi6XsFLW5YE2rZ9+pRcKLpyPildb8Ed", + "O42Tj3upomXBit5hr4/TSIzoHBX8Tpas7PsYHnowkcx95XPZI7fv8Hp/HwVn0AXlQnvarvlCWKx2jq4z", + "RnL7lrPihLyaE6BN01Zsh4tScXQvEACu0Tc19p7LqQCf1aoAL0EuCBXbrlFWM2O8Jfwtu2Db95GHxYGW", + "eueORfc8bEVthwuPW3OqZE01WUmw0udMmHLrPLwSKJgGpubCoKtJywu0B0jkk2lvRaQ/HPJqjZzZaFWR", + "RSlnjnYEXDwLyOj7DJOJHy0A+gZIRFKebnvJ7ls9XrMhb97DV2fHu9Yl27mmKyPXnCsNfoKMOlJP48tw", + "BRxzTox9UP6xZMBFSQXOfG080v7yptA7+CiBsyUThl+yjJV8wWepELCctl5M7wTsPELDCJrwOeFGE6dC", + "tUBwQRQVC2a5F8txSE1LDFhJQlNSbbIlo8rMGB3wm4ODaXzoW8u2/cnakiwpSi7Y1G4O21g85nYnFBNs", + "zQq7Gq5cG2Lf8HrgqQeAEPDUEYyCx3eHPYQ9S8+14iJzW5dwBPX8S9hdz6B6t8D4KgFc+H3FILZDrjU4", + "MBdEurCEntN9bUXQNGgVVYbnvBpnd0NAfmz1sYPs492S3Jqcd5myHv+UBBkbZ3bN/ZlqjQ7tdl3+sfOj", + "o9wDUJ8QcFVzmzQrwcc9BJXheVMFzvd+qRhkNQSOHmKP/eTttceXbkm1v3gQQuLfiVEc6wAxa9DX0tEI", + "f2O5g9t5S3ZJh3Z62DcOfMO77m7AQvRDQLxTKQbJep847wjnvd/sv5be1WVpqU0tLoRcW3HmEP+26QSv", + "fB/gSwlsCn72iOFAfKCjo7Fw/H0+B/qRES4Ke4lA6KDGR/TInGPgREOTLS1f2B9P7AAWu+wAo0dIoa0b", + "EjhsKUscmPwg4/snFocAKRiHd4X6seGBif5maSkc2HTg2NGfnos0xuX+lls5ocUVAWAQhjVjTKBbPuFi", + "Siwpu6SlJWVGImsaBkmLWg9bUpJj3PWjIREsrSHCFQHnctCakNe5ympi9t8DnZZNdkA8k5sMwhr7sEJ0", + "YlVlgYhJUW4xCKgrp8MIdj0yBwzxXsoXbIvxRxARB7cENLKOfsxYKS2nL3sY1hzUHuCvC/gNQrObwU9h", + "swbUQ867QbsdUWx7px7gr4fQ7iHg0DUA6Orfg3O10/DsVcq0WZn+w9+8htPGmR0pcpqMDF3FPsK3sSh5", + "igP721fjBZ/WH7vcT1JZ12pFsMnM6aEiWSj1+llylEuhmdA1BIoamcvypKel06xkIEZkLYYsu2CJIK93", + "vnGktyMP+dzK548i6UCxBdeGtUI4Q/xBE16xhbDHihrDlB3+/zz8z7MPT7P/odnvj7O//PvpL398/fHR", + "F70fn3z87rv/1/7pq4/fPfrPf5sMPMvMsttynl7TWynDwweNCTRuLe3Oob6UhmUg92WXtEyZ916CUJjk", + "tFoHSTDOmA/o3GGiC7bNCl7WaVz8IVBBXc+AUnNBGLWUkJp8Cdx0a0bbZsdsIP8MrOo1vbFFjUBnZY++", + "PfBngtcderrrEieQKXXs/cMZ3McdZA04oxesROPlcEIQvGiFbXiyy3DQuxiFH3uXtBhBMfzy4EjJtbT9", + "QYdXAZZ04Fu4iUKSdW9FY3VA6xAyG7OgaxqUXLeu64lXF+t73ChpFYv7eI3l9Ycfu7xk5qZx3g5wYIeo", + "LJEB6uEU3BU32B58iuwi/cfVihHaCRx4QSLmEkP1RZfJ7OBZCCsedxaeV3BRzrIOL+FuXvbmcI4lhC1c", + "ewr9yFzJFVy2Pq8ZKyAH9BItrGuels6sLqNUH18svQQBZa8dmNHyb2z7s20Lp2p7ew5z7C1p1DReyvMS", + "x7WO5no2rxTmuxH3Yj4GLQyhPeQeQttEy0J94A0o5UKnYvwWTUhsjAUzZoVitmF5bRq1Z0e5HvT/d8sD", + "dg0J6fDFyOcA81/t5hRgf9xYe07sx0Aeb/PAaFUpeUnLzNlyk9QcWnhr7x3zWukL9f6vT1//6CAGAyKj", + "KguyRnoh0KiRMe7tWiyrIfcYg0ER5RUA3SfdGXO5bhmA15BSoiO6WubJYRFuTGPEj66pMwjPPat9oHnX", + "ORngEnc5GzQKH/Q1aPsX0EvKS6+y9zCmnwpcUuPKcfBrEQ9wbT+FyK8ku1H637u86Zuwh9DEM+zIGLHC", + "vCWaSJcZojksK4yCUQDQckW3FltQLdunOKJegWYn0yVPmcXa6koCrQbkWTuUfVp3DWK/6xE6sQ5Y0eDJ", + "7fN+/kO7NZPO2a0W/LeaEV4wYewnBXeucw3trfO5xa4svSQs2JiD7A7lF5jwEMnF5e251uLCKFeRX6x8", + "krAm4qm59YSzu44c06hw+3wcALFbiImdiHrgvgiqSY9FwcJARcuMfIB3YTxjj20Y8AyM7p3gzs5xhVPZ", + "n2nUC0our1OaPhwkB8Vpoq4l/ehsruTvKS/adX/aaELslR50tPTSuScDUgzvZAK8whGFBFvXBSlIvdcG", + "qvs6BttGk362OZzBSzbEd8c2mLZL6gAhh/sGYSBUnZ//goKlt/NSgRfsOaSxbYk86WsaOyif4vjNNXUw", + "9/URdD2j+UViMY1XYMsSbSTxnULKtPbpnJDIwTC0ddnHKqZW3LTJfSNRXZWzxWlH87QNCwvYFDOvLgNg", + "qWVimFqsqTA+h5wjYK63ZmjSsb3WUmkDiT6TqyxYzle0HDDvNQSy4AuOSd9qzaKUZa4/qSQXBpGm4Loq", + "6RbdLZsdeTUnj6cR8XKHUPBLrvmsZNDiS2wxoxp4kUbD5LvYVTFhlhqaPxnRfFmLQrHCLF02PS1JEDpA", + "QdPkX2RmzZggj6Hdl38hD8HLRfNL9shunuMpJ2df/gUsjPjH4zQth5Ssg7TVk/Q01oJPD3a1j6IbLE1r", + "MQX5QXcGu4y5MdDSEfz9N2ZFBV2ksn3tgAX7NHb9zj6IArOJAstEuEnPywy1VCdbUr1MZW7O5WrFzcr5", + "O2i5stjSJMTCufwoaNNHch3A8R/BA7kiaeXa3Wp80mmqf6Ar1t7EKaGa6NqC2iitHHE7IS4VXIG5OBtt", + "ImwJZrtGjzTU+c6jXNS1mWf/EWUjPRmCMpt9+3Uf0meYzdSlKcW5xgN+59utmGbqctxF82yS60MeCimy", + "lSUPxSNHqdt3btCdKU2Wuw4nu4ccyyPZUbLdWEUjKnst/BI7BrwmxoVlHIR2B6/szhGwVgls+Onta8cP", + "rKRibd3qzMcUtTgLxYzi7BJCL9JnY8e85hGoctTmXwf6T2tD98xhxED5G5ti1THQvL8dzn89LHtI6JXy", + "4oKxiovFKfpvAzONo3bZ6JkU9YDGspKWd+K0JNCIVHRrdzmwoDt8w+eM6SyXZcnypIzaib6yzUlFOV6b", + "OMOmd3zcMdeCCaa5HnjOz88/LJZWQrGf7UscaVkwIAB97vTdX1EP+ECE/YIJC/erF/ug7g3cdqvAUKe9", + "OpyWP9hPro8dzKXvzWDe4V227Sy8P/p0vwinbX/3W+tiGNQAYruvgX53sWus8t8PlOHVGApHNTUtfWwn", + "YPecKVfbpQUO6GCg+gZjRHNxsdc3f2+6ireu7bBT/fn5ByUKe3LPXfgc+ki17dh4mGsKdgkmigb6fEn5", + "gE+qZiw9of1gZ3wnleHotMPYJ3bgM4rmF0kF5Hv7RQcnPvS0j9z59OhALrBG/Gj7vPezpYyxfMW0oasq", + "uXdG253DtwDeFbt9oYslmJrlUhTaYlDOCKukXu7LKKDTU20ETFZyjbxOTJlzqTD7LPCuRnaivcduyc64", + "9jaMmZLSDAFq4WwlJJDSEFqbpX3CfBwBg1oB3ZVg9BvIrSIKeiJvLJfh8/bSstxOCTcPcBzlPDspWTF1", + "UTJiFGNkvZSakZLRS9bUW4HRHmjyfsMLDdVUSrbhuVwoWi15TqQqmMJCPLY5yNLYyc33+IS4qF4XB/F+", + "I2B5obhBvE5cpo9eCRateMVTZOG6P0MZDM3KS6ZPyPu1RCB0k9tAW+63XaOiNhgzWPD5nAH1gOWAKA79", + "mg8RTFA5BkINwrBuTXdPA3oYluklffLNt0OI9uSbb1O49u77p0+++dZywlQQWm94yanaxs1sqymZ1bw0", + "LtE2JZcsN1LFGgcutGG06OEWaqPcLMDLzGuROze00CWu7/Pu+6fffPnk/z755lunvopm8VHQLsCOiUuu", + "pLCfvMIwYIibMszGNlybT8AtmY3IQF5Over2aHI4lo14jo2IC7xom3M7JGyF+il/8UtWLJiaNg+xpatN", + "zhEr3EkVccBzhiFi9l3kwihZ1DnDTBfvWnQjAov3QArlEyJ3G7jrvsBSA6fXpAaehZBXIAE/RoFMyPYK", + "4Y6xS6YwpqcZ6CE+DhFc2lAFfkrgtuSWyopH6ae9rhaKFmycFwI8Vj9hj5C4wY9wKQ8b4GfbvitgtWSA", + "FmedZmCjQA4GRW+aNzf15uygEoPy29uhCMqXWLRIsRJD3aAyCtbs6Ulnc8YyywgmMd5KTZCAK89ZZTE9", + "LtLJmH1r8KbDXYbigZ5pC0HQGISX1mABTFlOy7wuUZTYwUKuc1qCJahB7JLNjbS4Fxcha0wB3M41Aw9x", + "LCmC8yn7hkU9IG3UJVNb1wI1L76Ch703quO602eVs5JdsjIJOKMKeIfv5ZqsqNiGs7BTNGBMo8i4ADky", + "weAhgqf9k1MKReDjPXMIuRtIexQDm1vE51wxxWXBc8LFr8xd9Fh0AIzBUkBSGC5qqIulWAM3PvUEQnS7", + "Ybh9DFBJl2ILFzXMAtZEcQi2bp12EQkK7WAIbegFQ7B9MLHjbsaeqWKaF3UasrmieRuyw5DRXd631LBT", + "FY5W3xBedohXuOS7Ll0Xlzto0zmt/i4N0qkWXR5DrGiI+CKOhiecxV0GKt9yQGMgjYRHO8rdEsa+ZEq3", + "3ZAjMwHb7BnbtmiNj3m5fGqDw2fJvD+aHpxvi+S4wTnPP2PgPfR3aRVSOziQtCwAoNfc5MssFTjiAMAW", + "Foa3XRG+PyVyF3AL2XzOcjMGBojawYpYg1DgZwvFC0YLiBhvoq4w3qoLysMfJLFD64jlEZqDINFwPDDK", + "owMSmgcM2Yf8P8uRuO8C7sETYsQ18DyOO/vklrk2Dnlehah3SrZMw64E7/LojkBmkrSJ109asJJud00J", + "DdqTBp7XG7fxzYEEHvZBQW/2wSBkP7W7Z7smt026Cw7Xs38r4lI7vZOUCSc3n0szhFC5rIQJn82kDcsi", + "M10BGvtKvqGkYlMr8Y6NijeTFiMd1+iDT3rbAF/8PsAf3Y34xNYVX4HYvZO4kl/SiBIllU2iTBG+RyHR", + "GGcA6/fJ96grsDsSmzqWLI9R92DfUvv010taDgRavmWVYhr0BJS8/+vT184pZijcMk9HOp6ff6DG4hT0", + "I4PJpj5OJwOZIc7PP8yAYmLeh3Aafeti0ofaEiJuu9vPvd5Xc8kbSqIabaj3xe8D9DcfAEYqyp2jVxNr", + "2t9ZF3Tcj+4eE0TWHHB3ES6qd/AKfU/18iXNjVTbfgZXK1oPpNY5P/9gz/uQLf7y2zS5tyCkJ3kf5e9p", + "q8iC/x/43nl+SM57eXwIJPJZUqc5839aST9K2hO+T6aTnh6gOYs4D3HCz2gJnzG3IfGV3PonPZiuuZhl", + "IWwkVdFxOnHpluMcs3tDwbjOVnyhgOVJjzqcJjp6ohIvDLLaiYrRjq0Z5sU7SNpaeAfiBrzoRXAzpxD6", + "lSjYhqnGMvOmWV3HUo7qIygMrLNGmZqmTYjsd8sfYBy+nUIbVuzQ1swPvIro8VNaNm3U+OXVxhcZsMki", + "WzO+WKY39scrDW3Z6P2Hdnn3h5YicG9A6//UXkjAyAFCO2/I8M5k6BHFBt8AM2C/N0tc/n0JSVXMyjDV", + "ALimOBAR/mNgs7uVhRKEWvNVVaLzpyMlvdxXByWaaAJMbj9e6aaDPm49fINd2SPx5qM2rgrL/pRUu2M1", + "/i6ey1VVsmHmuaIC2ec5F05uXy+piYupexuQzPNaNUbcbjTGz7TkWOVXQxZDIWUFaQsrw4X9DyRwkLXB", + "/zOq7H/Qqaj9P8SqiE+yQ03gXCD5lR/IR3JOphPsPPGYneSiko5JvU1pp7Py5wlO2GBLE4wVEJDQZJM+", + "pblB+6dz1hTMrKW6SIgxMw36pJZfVVz2tU9NqTJ1RVFEocGDwqVwDVnhAmgOMl1r9K5p+U/spZVsU1lc", + "OxzAQq0uR0IYNk+KS6ac7UO6nJJo5cA0tb2ETcSBd8iaUqT6igmARrmh9CW0xDY3TCKqBtO+TaDWUrGc", + "HPkK9V02c7WtjDyFNtDkVBtV50aj12YzZw8r7Uaj89L++nldlsJyAlJztGcamSl2yeiQmh5ctdhvNbOH", + "DKY625iEAVIHO5Zod/cYx05vLQASu8Jg0BQ62JVbnyyT2j1f0eoDzvILychbhDiUUgCPvJVeVId7buFQ", + "KdA1LU02KOU4/pK8o6WJ2QgLkPPzCB4yw4lrkYNNjp5/CpHDwnR1FLQLZsUudn99BXZ/kHbAvOGhQA6s", + "faUumcJY6NHo8LPv8XE6udN1vA03tk8VovWNW0W8KRFpSKtY/Fd/nZpUyVQUJJpfE7gbCV9BuLpMGLW9", + "Spohvsh0KQ9Y3ju+eGc77NlS36y3p6VcM5XZeXcccelNjRhvgy1bqaRDLRccDz0lWEHsYvTVNgIHPmgn", + "XJf9e9GM3XFKoWUuRdaa/W6pDtLLDLArC1kO9uweXbV3r/Ky9aFUC4jElotFOvOjJfQXbHs/dAkJj+Pe", + "eYKJd1iZA4LGD8GhITIyrZ0RGY2EbUZnTxUJK64Bp+nK5ey4V6Z9rxr/ohXPlaTgjNGknGY9DtYJe+DL", + "GHZjl4NJWrmMibmx8/ttxYJTbr/UzopWXt4COdwywSe3qbQib4M7ct+jNJfCUA4FdZLMPTrjsrICQtXo", + "xk/uFfr+HL3MHV+T3fuTrwCBIsNV7L9t/9/fMqMYu3sP1wu2zUo+Z4YPGKTLuV3J39iW+GYnN8ZTDOVI", + "ahn8QPNQYkxAk/eJSIVfFvAlTi9FkI5CkLT2f2lSMMPUyqLiUq7Jqs6XwLvTBfMJlsBgA57lnYlao/uM", + "FO30YC4+UFc0x4Ew7L+kasEUcZH4oS6JNwCtKId70ngDd+NzwVGMpoxx+9I+vcFUABHtAtNplAMqkV3K", + "g3HBtqdoGYTfr0BIhlNJDQAGeaVuEaRrpaeKc5rtwdeLllEVi321kr8F8G/QuGrhcyqEA42r/WxtY5cH", + "64DrUGvWX+f4aJx4bxMibrO2sZ4B/c0dMOjvs+MPlGxx5l6g49CXAHzkn1/+kyg2Zwr0Vl98AcN/8cXU", + "+Sv880n7s8W2L75IOzUlb87N+Q2ESgB2DDddEjvaBWA7NlR85DWG06Ljmn3QpACXzbLshDyJgkCyAWBP", + "KESAsFJWLNkaipXFLygkgFNsUZcUQ324EEy1Oo3J9IPiv9kIp+qCP99vRKptzE5C62g7UgVCoyrMV6uc", + "2yknh3mWcshodNURm5xIzYiYXeU6I77ElC5hRB9hep0x37sx9pRwPD//oBcC1HJeGcd9lgBggPGE29gU", + "Mgf4Mo8+U1EIZ2O/1bR04XoCguPeQ9qe/IIJrOBoqZyrvkuY0LVyKkELK4xnQXHDyPgx102Tq9ZyHC4I", + "dn7+QeWo/XUe7S4ZBGSewq6WzSjs4cjdRVVseytiDiWjs5wttXO5hj6+GHxF94legMZqNWzD72SLjiNL", + "IOOi7z8wfFO/pCmFns5F2CSV7LzMmP/+4asXjwjvFkOPsz5Ggtb+ZcclVMZBhBlGerB0c08eAsWcsaFw", + "nk5gIZmzAVXwzvIddiyQCrGOB7TqumDvhXJkVoXvqYYqHa55E0l/H1MptIAkr14k+YxWdtyDS0JMJwsl", + "63Tk9kKBaajrC2qFAGCwUIBH57LTJ998Swq+YNqckH9Acj18fPt10dqnSXhTb61VypMAYCFBK7JBLhgx", + "mnPpDrQXHMxdUCIMc/cnfJX85NMJ8CWZ2aQC3F/1eBZSuQhOyC0a0ZuW2/tNhLVzYRRF4pvJ+TyZb/fv", + "8HvjFqE8TVasf+ojqPIF2yp2Vd7lb9A5lBgdpjwlUB6otXM1wlMyOhA5UG4S1+erJ1lzg07Ia9ubMDGX", + "ykrVqxosfWwDifmcwS3mUiF9nWnKQ0PmOvE7UxKUBoJIZ9ju3rGw2RBlSXPg57WLIrYwhMS6QTH58B1w", + "M1ME8hHKpP2rRmphOLI/dht/jnaxsg+PBfofS14msKCS9ruO4ZgSIYkE56C4JaY1aLIuIswuLLyFSHd7", + "zeN04kXa1G8xAeIhX0e1NRqNRL6koqnYvr8kQx8nx9Vk7hUlSlzzdMUIu4AFLmBxI3B+Wkc9IQfCQ+0H", + "YEMUwwyJQXt2x8mA6HbFhLki5fsRe6NvAtSzVbslADUgAfje++oAX7BtZmR6bIaGJeTMg6gFelKkttEa", + "pwNyT4ix8zXwG94Vb5BlEeY1GHQj06XXkzqRLviTXbBt4+0S1wpEsekKUhY+i2kt+Hu+Yo1cgoxcigXi", + "o55EFC/Tci3mREKS/WDHcsIwu7FCD2AF9t2NE6PtvBHaRobeXp6jK9yCyA0JcnHsCPPYVqwd2AeOiUFR", + "10pyATqDE/IiJIkBP0SMtW8yx6A+q+utiBlRQpZkrrzeiyqvrwaHRnB2g1uTIASuAfJGtk2fS3JNaD6H", + "BkOKIN9sM2eqaZdSxviWc/V707CvB/LNqgo8CwY0Wq6VNhUYh4ZOunHKrOh24pnByXRil2X/sWDbf+fq", + "d/tPVZVQ5bSa930y0xfY4UQG8yRC3CdtqbXFSIab2KDWHg3ozjp6LnB3jjV4w6t6qHoyVqBjOvLmh+e0", + "LN9vhPMD7Ie97fC8pBWGvr12HpeBQlsy7tx3vdbKUYfYEkPz3LJ4RZPyIYLzgSbduimYCKJfOWWHN+Ze", + "Ct1lAWLcpGoxuG5QWPXZUJ4TqhY1ph+6g/XtWcGAZEMrXriEjP1Cdo5lQ7JQK1YQqVwqLz53edqGKjns", + "L1OFu1c5npHnDWvYZKEYwPSpFX5Y5ZKtS5HlwbPcvpNWwjSSnKNH9vnkhLzCnDGK0QIJrOKGpeootdYP", + "yW/XDMo6e4zOwulGVfBO7C1q1dzSgNmKgf9EokTaZ1mPC05M1wMnNkSVkKtqH9InOKHn/WJiUCxASPMZ", + "ndOoylzn5x9YBRerXfYijqOoqlCsq2R233+rIQDOEmwYdkBHKxXjCzFQix0QZE79Q6C7x5V8DtpUyqUb", + "jA9e916JwI5fjYiC5QUHwxQCtMiglP0Ol+8EeQ17MVAcHglcSDapm9gb7VYZ1cAYt0RPZn6MVgiI7VnZ", + "m1zfFUqqXbuOWmeAFtXY17cVYJSovBa/hd2h93FmkZVzJ2eGJRtKu3CkT4pl/v30FEsUWM2hbuKVzsVT", + "8jtT0gmrYSh7IRrduEsD7vKjniQ6hcIqutetO+WBBWtw8Tu4w8ECUOfnHza0x2UATNfgL65Ww2vvGb8c", + "KCUSn7E3lbkaItesBIQz7tjYJuaybxGjBexrVH8h9vFCIhMKCuBuu5oqgCx0PVDGZOdpznee5o7xWxmY", + "1l46xPTDafLppEnMdbX2O449UnGdwzGKTUWp/tRjLn9wHhiFGl5Cvi5y+Fl3oMewKZ1S9BJ9ikZ0K5Vp", + "x3h5+E6IIyHpRN6alXNPzbxtzluPY0yzLxO+ayta3Wj1uL3EI4J42OeADXocNHnN3MOcSGWOIzS+DZbX", + "9NbIBMt44Nr96OkjhK/ddFY0rgqhl7IuCywMsYJcbI2MmTgdVwAq8IVNQS504wCvizjIWkczxJtNyCs7", + "Mi3XdKu9orbBrOHh/K5i+YiEkjBO1oja5fTeqBzdxFnOK86ECT438blYJB9Wb6YHdmpSS3Uwixy/DFoL", + "53hPm0pqbdObt7y5alE0eqGnbptp2VYX4MBeFW3bPPdj+xWFI40etP0pRVL19MKW7iF6zja6k9o5veKh", + "RA57IZXDaYbJm5CiHQA8YJQRtpE9tDdUXbQeQXdZ3QBigekEWqO2eIwoCYBmJaYi7cQgD0XIaFY6U8aP", + "9azkOZgRwOk7GBacx39B3lJRyBV56ZP5PPz57ctHRDFdl8Yjmc9sbJHPQfJpywkMLrxSc7fyd1G0TFg+", + "F86isuDaqITi8s5XBTkf9zkc2UZzbRqvIzRYY7rHXkA4d1Qw/QzBhBdsmxW8rAcR2ba6KNoJN3U9g7Jw", + "XGBW3hk1OXiz9EDQO6be4+Fg25S4VHBzuO5Kx10YWK67Ma1Zqs79uW8ItEeU8ObV3dTTWW4OJZ+uG9JP", + "N9PV+ENkD5swiSgRsD1PXxCl8/Bfi8uKpsA4Lct9aFeVsGG22i6lTdFPETxDI0PCXpfT9nhpt1PPZ8Ek", + "UPiM9zkuOyG8/u5taTgj6F+4YqVlxPzMa1HozhY25fB32F938j6O9fFtdppyh5iCsZxAK2i2DQkYLl3Q", + "SRMvrbXMeWOEh1qTWFXy76LcuqR03YoezVZWSl7yIlWIvpQLnmtUwRxqMX7t+36cTlZ1afgVx3nj+6IJ", + "O/0c8oV7CkVBVUFY8eSbb778SzsVwj0iV/1NSrr3uGU5LSM1PG/zsWF1I4iYP8qTheyTrEFjm1o0todg", + "XEslbh1vIwNAhkPfvaLVOYjMtoRGqC4t214a3vw0tb8tqV42pDMqWwxlpClx9Krr9QfxRZGh747Dzx1i", + "Z9dyzOhcjyHC0VyS+3A3YvKI+DCWJL6JKElvhSu3RNS7WnzxQZew11XJLG/X0MDBNDr+aPDJ93O+4/0q", + "//F46V2HBlA6UFpOBPOyWmay4bhAQdBAdQXv4N7+vIvhSuXFWyqmLURp75ulSmYa2ZV/s8l8mMirftDZ", + "vuvsaSczCezbIIdbXXyiBDa7cOB+ZHFIO2LtZpmHcjGQMYF5IRlVNwnVMPccZYXdhfqD+Vbb8vP4jCYO", + "nK6X25B7mq68g9r7KHQ0ztBFXiH6N16NwMcKzFfjUu6h8dcVAGjv1/VD8j9ChMBcYnYDYWhumtTik6du", + "pIkr8jtZGlPps9PT9Xp94qc5yeXqdAFRTpmRdb489QNBGslW6jTXxVW/ss9uuTU81+Tpj6+ASeamZBAw", + "AUcXJdQ9mzw5eYypF5mgFZ+cTb46eXzyJV6RJeDFKaY5npz98XE6Ob18cho7Ry1SgQ/vGFX5EtHYtT2B", + "NIIMxdlXRWj0Uqqnfjhn6AIb8eTsQy9DHKhWIUyE279/q5naTnxh9Fjv15hf+/RwfwA96qU0evyaWmFK", + "AsVI7rn2yLcA3AcIu2SCcMTEkq+48SpRxWi+dGxaAmZoeyDATS0UumARvCfkJ82iWmTyAmKOUL7wEQy+", + "lFboNACYHSIFV0Pj+tHjuGtOtgEHUCq8rWUBUXZgJhORp/JJq5iP08378neY7TTfklqUlqH0BiewE+uw", + "NKjzhOlscup2wIX3eTdpPXwCfpLMQZhZCA88EVdXG4Rh4B6cYzeoNZ2s7HB8GjK3xp4iUzRYyy3kvtPM", + "tgu5UDsmhanz9LDD4ufIFQl8ENCPZGjBzuc8o2WZWmZkXewu868bt8wG+3G1us6X4JPUBbQLGWbzdJko", + "QkCR25up6x/5ifjYzOAfElqK1gaO6GO3g22qUhZscjanpWbp7WG4yNbWBI7Qe+Di3jlXmE5UqkbnW51F", + "/iCTVkStbSGkSOdK7aUkNFsg3fbRmRx66+Da3N8rZ6e41n3zfreRU4WRTWg5ZGK1l9Blb0q+GiE2fpja", + "7fWm3f25C/4Ly5XkgKTgHsM1LUu5ZoWr8hmQORQ9cHc2vEyOP3R2TRdbdkLeol+bjuJBmrHAV0cxIuTa", + "uQAOn1AorXjAocT5W4ff6K5j0o4ZfrGyKpZUgMv35PFjz045dXM02umvGgWjZsBhh+5DwsNSd9JXp9oZ", + "eh9qjqIdFA9ujWzEqqrNsLPIxmTwePdH/kk7ulnRBRfOxQqUuCt6gTwuBgo6D0d/YX2mBcsRBOuc4yEc", + "fozQpTZsWnsDfkmyv23IH4Kn0yO7wK+vdY6DtTSGa1p01uEbjgH7rUNA9NLGWhwfp5NvPvclWKSmCw2l", + "UIANn/zyscPcn/7hXYx58XGQ038t5UVdBRtBVK+qz/BjW3evnm2BSOxk+IPlwZNhIClQ/6ChKAHISbxH", + "RtXsIPb1X5MoHznTI2d6N5zprbzWB7zRt/gmp9/B4zM4+frx18eX/P685CW8r3te8tMeBdj3tIvItbJL", + "R2WF5Lbctp+/3OXm2cEAPK0qSP8AemB9n1iBG5dk/qzP8lG1eiXV6g0/pZ37foAE3MzS3NSjPBwFWXU2", + "9sgRHDmCz5EjCCGdn4QP8KLJ/Xn/b8XOeHzzj2/+nb354UaPe+jj6pnH992/70GJcnzUj4/65/aoJzI4", + "H/bEe21lWpl5rSf/OQ79NAbtKP8feYEjL3A78n+LABwq+h8ZgkRWlSNbcGQLPm+24HCZPzAEHVvojbAC", + "RyXA8eE/PvyfXAlwfOyP0v/xmf/8n/k4Fmys7147tc/7VrE5xRzZZgURbG0vm5FElvYx2vPCxwPte+CP", + "78bNxOJEFbDsLHO+cdTZ511yFYWbeqBCGobZ1wehgEwnMNjBrvIYsz7kKR++/pGc2OcTjye9uVToqd3j", + "C4gsnPMS/PZ+tZvmEbFuEnIET0+fGT9EokLWes0XJAt5EewvK/wJYm3f8YX9qcSfIMofY5xTW6D5YngP", + "NHRb4T92vFGLdJc/Wkg7wcFs65j39JGkOd/h6V4lnGXbmxjKed+076ufkhpihZM5hqHFU6+4yHZOHxrc", + "CAgzNpcu7iaCgW72wOAbHBqXcauCjF9ZtKYFtwQYaluTN47eUEHevnxOvvrqq78QvPdWsEF0GVowDolV", + "RGLgAt0oqAmfx1Chty+fAwDvgkvrqFZ7DzVg1E2tHEa8fwv/E0d4/inD7O5S3dK9VLhqH2KBQiWWVdrN", + "pYTiSzsVFjcraP9JBOTppCtVXL+OYkdQau9kZ8JjmNm/lNw6xi4d55FoG1+GUkkcYFK+fTPvSxAgUH5o", + "FYYIlw45hpAduElrlyTo2OxqjPdR43zUHBxNzX9GU/O/dLBytE+nf7SJ9f6g5ag63JAOs2mSDlhOscTd", + "J2MvW/ynMxjeGtk5kNjcXdDoNa1IRxPMZ8LK9ojQ6UxuBgnR/wb2z0r/LV4UruFMboi9V1PHvuhO5tfQ", + "AFo7ncMz91tT7Nfp9xfS1UHLLSWhaoHlnB/AYFwszmCAByfkpVSEAzWpHR+CDbkwZ18++epr10TRNZlt", + "DdNTBw9AR779GqCxXR/Mvv36gbc+UMjobn86e/rdd26MSnFh6KxkTsPQm1MbdbZkZSldB8cfs15D++Hs", + "v/77f05OTh6MIeVyY6n5U1H8QFfs7on60+bsuICjyW70RNrt7mrTkwwo7u94xdB1X4ZdxP+Z3KSuu70z", + "Ud6So9n++Gbc3Juh69WKqq2l9czAtY9QzXnLoRKgw41e+bFh+tDnpnlhoCJ7eEIgsyptc4FaKsthlmzD", + "c7lQtFpy+6JsT0bpZJ4BeHdOb4/KgfulHBiuz1zxYtMplU64KNgmLb8HdB+laXgmNy/clDJZA/RzUAfg", + "bcCFjyFMz+Lr3L76x5fu+NLd5kuHaDfijTtIq3NayoU+QLVDbPsRQsFrudCfRsdzfJ5uxuvtE7s0/Un9", + "i6DMUTDU90rhYyJeV7tqt30LW2VNHdvbycd7/9maW7V5lHKR+Rfj8DRAixe262fNO11DFbtLCbg7oCq2", + "ZEPLXQLTqGCoo2H3+Dge8Fq1fBGwQPIdeiHsn92OvkeLeKPz1YKbofnst8ndRwsew7+O4V9H0fQuvQfg", + "kE//8Ndzv8cAXPMxSc5tw/HSZFyx/OgrcKu+AkDmxtLCO0wqDVMeyc1RmXe/XR26FPN0RksqcrZXI4es", + "tzaghvZ1e9ZLCQTF5cMHArOTovrJjrLRUTY6lq47BjaNDWy6MabrZrmRmHiOktLecMGP2TpTr96seRqO", + "ItufiQE5JNVFyzwBulhHn3blu8AsF/ZJxcwXO2W+Y7aLY7aLY7aLY7aLY7aLT2ONPualOOalOIpv/9p5", + "KcZ4nDgjpgVUCoauzK3G+PwPciG37YTSW9RzuZpxwRoByK+gKRZqpD0oaLSkJrzDvqGRRAcvgz3rypQs", + "B95XcMIBoThn/BL+O1eM/c4yQ5Vlrse8t63VeAChNGY0f1wb86C1WaYYFW7E5wPRroyqWkEaWhNy1RJK", + "/Eqmlk/eypqs4bKU/AL6u7qadtNXUJC1U6PVSGJUPWicdt0zgGdv5pHpXRiAjklUjklUjklU/gTakFkp", + "8wt9+gccdYZ6hL1GbOg0pMR4Zj/uU1zgZcTp0mmhYoCuSdS+Z7Rgikj76M9Lujgh/7CXE24fuJYaT6Gn", + "jc4G1kgKyVAX4hQAXR5AD9C/JUyZ2SlvlwTujFaBkzgGhn/G13OUajLyDB2bgberkfTseppt5BrY8S7T", + "HsTEw3L7Bi/Vo6bzqOk8ajrvraYzJh6zLVkoWVfk1Qt7zbhGjAhYgweVucQS6M8Aup41VYWe+sQT+ZIq", + "msPWgez071NyCm2/CyP99Pa1H2ZgyQBItlOhek1cO2p+j3mOj3mOj/rkoz75qE8+6pOP+uR/dX3yp9QB", + "337t1KOW+ahlPqqxPmmYVHy0p39YmWh/oBSx4nTZeiGHVM4x1o2JlnJC2d3llLtDEhJt10GXdfzlPMYU", + "HcnLfdGSf5xONFOX/q7XqpycTZbGVPrs9JRt6Koq2UkuV6eQtMP1/yPw/XK1gocq/OJGjn5xpMx232RS", + "cfv2lple08WCqczOjDA/OXk8+fj/AwAA//9X7P8JDYABAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/api/generated/v2/types.go b/api/generated/v2/types.go index fa8fbb2c3..b234ab79c 100644 --- a/api/generated/v2/types.go +++ b/api/generated/v2/types.go @@ -1838,7 +1838,7 @@ type SearchForTransactionsParams struct { // * lsig - LogicSig SigType *SearchForTransactionsParamsSigType `form:"sig-type,omitempty" json:"sig-type,omitempty"` - // GroupId Lookup transactions by group ID. + // GroupId Lookup transactions by group ID. This field must be base64-encoded, and afterwards, base64 characters like +, / and = must be URL-encoded GroupId *string `form:"group-id,omitempty" json:"group-id,omitempty"` // Txid Lookup the specific transaction by ID.