From 26609e49492ea330a20ba5a567f6b5cacce48aa6 Mon Sep 17 00:00:00 2001 From: beer-1 <147697694+beer-1@users.noreply.github.com> Date: Sun, 7 Apr 2024 13:00:05 +0900 Subject: [PATCH 1/2] fix wasm stargate query --- app/app.go | 6 +- app/wasmtesting/common_test.go | 328 +++++++++++++++++++++++++++++++ app/wasmtesting/contracts | 1 + app/wasmtesting/stargate_test.go | 54 +++++ 4 files changed, 386 insertions(+), 3 deletions(-) create mode 100644 app/wasmtesting/common_test.go create mode 160000 app/wasmtesting/contracts create mode 100644 app/wasmtesting/stargate_test.go diff --git a/app/app.go b/app/app.go index fca41ba..a9c06e1 100644 --- a/app/app.go +++ b/app/app.go @@ -680,9 +680,9 @@ func NewMinitiaApp( // allow slinky queries queryAllowlist := make(map[string]proto.Message) - queryAllowlist["/slinky.oracle.v1.Query/GetAllCurrencyPairs"] = &oracletypes.GetAllCurrencyPairsRequest{} - queryAllowlist["/slinky.oracle.v1.Query/GetPrice"] = &oracletypes.GetPriceRequest{} - queryAllowlist["/slinky.oracle.v1.Query/GetPrices"] = &oracletypes.GetPricesRequest{} + queryAllowlist["/slinky.oracle.v1.Query/GetAllCurrencyPairs"] = &oracletypes.GetAllCurrencyPairsResponse{} + queryAllowlist["/slinky.oracle.v1.Query/GetPrice"] = &oracletypes.GetPriceResponse{} + queryAllowlist["/slinky.oracle.v1.Query/GetPrices"] = &oracletypes.GetPricesResponse{} // use accept list stargate querier wasmOpts = append(wasmOpts, wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{ diff --git a/app/wasmtesting/common_test.go b/app/wasmtesting/common_test.go new file mode 100644 index 0000000..7260177 --- /dev/null +++ b/app/wasmtesting/common_test.go @@ -0,0 +1,328 @@ +package wasm_hooks_test + +import ( + "encoding/binary" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/cometbft/cometbft/crypto" + "github.com/cometbft/cometbft/crypto/ed25519" + tmproto "github.com/cometbft/cometbft/proto/tendermint/types" + + "cosmossdk.io/log" + "cosmossdk.io/math" + "cosmossdk.io/store" + "cosmossdk.io/store/metrics" + storetypes "cosmossdk.io/store/types" + "cosmossdk.io/x/tx/signing" + dbm "github.com/cosmos/cosmos-db" + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + codecaddress "github.com/cosmos/cosmos-sdk/codec/address" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/runtime" + "github.com/cosmos/cosmos-sdk/std" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + "github.com/cosmos/cosmos-sdk/x/auth" + authcodec "github.com/cosmos/cosmos-sdk/x/auth/codec" + authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" + "github.com/cosmos/cosmos-sdk/x/auth/tx" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/cosmos/cosmos-sdk/x/bank" + bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + distributiontypes "github.com/cosmos/cosmos-sdk/x/distribution/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + "github.com/cosmos/gogoproto/proto" + + "github.com/CosmWasm/wasmd/x/wasm" + wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper" + wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" + + "github.com/skip-mev/slinky/x/oracle" + oraclekeeper "github.com/skip-mev/slinky/x/oracle/keeper" + oracletypes "github.com/skip-mev/slinky/x/oracle/types" +) + +var ModuleBasics = module.NewBasicManager( + auth.AppModuleBasic{}, + bank.AppModuleBasic{}, + wasm.AppModuleBasic{}, + oracle.AppModuleBasic{}, +) + +var ( + initiaSupply = math.NewInt(100_000_000_000) + testDenoms = []string{ + "test1", + "test2", + "test3", + "test4", + "test5", + } +) + +type EncodingConfig struct { + InterfaceRegistry codectypes.InterfaceRegistry + Codec codec.Codec + TxConfig client.TxConfig + Amino *codec.LegacyAmino +} + +func MakeTestCodec(t testing.TB) codec.Codec { + return MakeEncodingConfig(t).Codec +} + +func MakeEncodingConfig(_ testing.TB) EncodingConfig { + interfaceRegistry, _ := codectypes.NewInterfaceRegistryWithOptions(codectypes.InterfaceRegistryOptions{ + ProtoFiles: proto.HybridResolver, + SigningOptions: signing.Options{ + AddressCodec: codecaddress.NewBech32Codec(sdk.GetConfig().GetBech32AccountAddrPrefix()), + ValidatorAddressCodec: codecaddress.NewBech32Codec(sdk.GetConfig().GetBech32ValidatorAddrPrefix()), + }, + }) + appCodec := codec.NewProtoCodec(interfaceRegistry) + legacyAmino := codec.NewLegacyAmino() + txConfig := tx.NewTxConfig(appCodec, tx.DefaultSignModes) + + std.RegisterInterfaces(interfaceRegistry) + std.RegisterLegacyAminoCodec(legacyAmino) + + ModuleBasics.RegisterLegacyAminoCodec(legacyAmino) + ModuleBasics.RegisterInterfaces(interfaceRegistry) + + return EncodingConfig{ + InterfaceRegistry: interfaceRegistry, + Codec: appCodec, + TxConfig: txConfig, + Amino: legacyAmino, + } +} + +var bondDenom = sdk.DefaultBondDenom + +func initialTotalSupply() sdk.Coins { + faucetBalance := sdk.NewCoins(sdk.NewCoin(bondDenom, initiaSupply)) + for _, testDenom := range testDenoms { + faucetBalance = faucetBalance.Add(sdk.NewCoin(testDenom, initiaSupply)) + } + + return faucetBalance +} + +type TestFaucet struct { + t testing.TB + bankKeeper bankkeeper.Keeper + sender sdk.AccAddress + balance sdk.Coins + minterModuleName string +} + +func NewTestFaucet(t testing.TB, ctx sdk.Context, bankKeeper bankkeeper.Keeper, minterModuleName string, initiaSupply ...sdk.Coin) *TestFaucet { + require.NotEmpty(t, initiaSupply) + r := &TestFaucet{t: t, bankKeeper: bankKeeper, minterModuleName: minterModuleName} + _, _, addr := keyPubAddr() + r.sender = addr + r.Mint(ctx, addr, initiaSupply...) + r.balance = initiaSupply + return r +} + +func (f *TestFaucet) Mint(parentCtx sdk.Context, addr sdk.AccAddress, amounts ...sdk.Coin) { + amounts = sdk.Coins(amounts).Sort() + require.NotEmpty(f.t, amounts) + ctx := parentCtx.WithEventManager(sdk.NewEventManager()) // discard all faucet related events + err := f.bankKeeper.MintCoins(ctx, f.minterModuleName, amounts) + require.NoError(f.t, err) + err = f.bankKeeper.SendCoinsFromModuleToAccount(ctx, f.minterModuleName, addr, amounts) + require.NoError(f.t, err) + f.balance = f.balance.Add(amounts...) +} + +func (f *TestFaucet) Fund(parentCtx sdk.Context, receiver sdk.AccAddress, amounts ...sdk.Coin) { + require.NotEmpty(f.t, amounts) + // ensure faucet is always filled + if !f.balance.IsAllGTE(amounts) { + f.Mint(parentCtx, f.sender, amounts...) + } + ctx := parentCtx.WithEventManager(sdk.NewEventManager()) // discard all faucet related events + err := f.bankKeeper.SendCoins(ctx, f.sender, receiver, amounts) + require.NoError(f.t, err) + f.balance = f.balance.Sub(amounts...) +} + +func (f *TestFaucet) NewFundedAccount(ctx sdk.Context, amounts ...sdk.Coin) sdk.AccAddress { + _, _, addr := keyPubAddr() + f.Fund(ctx, addr, amounts...) + return addr +} + +type TestKeepers struct { + AccountKeeper authkeeper.AccountKeeper + BankKeeper bankkeeper.Keeper + WasmKeeper wasmkeeper.Keeper + OracleKeeper oraclekeeper.Keeper + + EncodingConfig EncodingConfig + Faucet *TestFaucet + MultiStore storetypes.CommitMultiStore +} + +// createDefaultTestInput common settings for createTestInput +func createDefaultTestInput(t testing.TB) (sdk.Context, TestKeepers) { + return createTestInput(t, false) +} + +// createTestInput encoders can be nil to accept the defaults, or set it to override some of the message handlers (like default) +func createTestInput(t testing.TB, isCheckTx bool) (sdk.Context, TestKeepers) { + // Load default move config + return _createTestInput(t, isCheckTx, dbm.NewMemDB()) +} + +var keyCounter uint64 + +// we need to make this deterministic (same every test run), as encoded address size and thus gas cost, +// depends on the actual bytes (due to ugly CanonicalAddress encoding) +func keyPubAddr() (crypto.PrivKey, crypto.PubKey, sdk.AccAddress) { + keyCounter++ + seed := make([]byte, 8) + binary.BigEndian.PutUint64(seed, keyCounter) + + key := ed25519.GenPrivKeyFromSecret(seed) + pub := key.PubKey() + addr := sdk.AccAddress(pub.Address()) + return key, pub, addr +} + +// encoders can be nil to accept the defaults, or set it to override some of the message handlers (like default) +func _createTestInput( + t testing.TB, + isCheckTx bool, + db dbm.DB, +) (sdk.Context, TestKeepers) { + keys := storetypes.NewKVStoreKeys( + authtypes.StoreKey, banktypes.StoreKey, stakingtypes.StoreKey, + distributiontypes.StoreKey, wasmtypes.StoreKey, + oracletypes.StoreKey, + ) + ms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics()) + for _, v := range keys { + ms.MountStoreWithDB(v, storetypes.StoreTypeIAVL, db) + } + memKeys := storetypes.NewMemoryStoreKeys() + for _, v := range memKeys { + ms.MountStoreWithDB(v, storetypes.StoreTypeMemory, db) + } + + require.NoError(t, ms.LoadLatestVersion()) + + ctx := sdk.NewContext(ms, tmproto.Header{ + Height: 1, + Time: time.Date(2020, time.April, 22, 12, 0, 0, 0, time.UTC), + }, isCheckTx, log.NewNopLogger()).WithHeaderHash(make([]byte, 32)) + + encodingConfig := MakeEncodingConfig(t) + appCodec := encodingConfig.Codec + + maccPerms := map[string][]string{ // module account permissions + authtypes.FeeCollectorName: nil, + + // for testing + authtypes.Minter: {authtypes.Minter, authtypes.Burner}, + } + + ac := authcodec.NewBech32Codec(sdk.GetConfig().GetBech32AccountAddrPrefix()) + + accountKeeper := authkeeper.NewAccountKeeper( + appCodec, + runtime.NewKVStoreService(keys[authtypes.StoreKey]), // target store + authtypes.ProtoBaseAccount, // prototype + maccPerms, + ac, + sdk.GetConfig().GetBech32AccountAddrPrefix(), + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + ) + blockedAddrs := make(map[string]bool) + for acc := range maccPerms { + blockedAddrs[authtypes.NewModuleAddress(acc).String()] = true + } + + bankKeeper := bankkeeper.NewBaseKeeper( + appCodec, + runtime.NewKVStoreService(keys[banktypes.StoreKey]), + accountKeeper, + blockedAddrs, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + ctx.Logger().With("module", "x/"+banktypes.ModuleName), + ) + require.NoError(t, bankKeeper.SetParams(ctx, banktypes.DefaultParams())) + + oracleKeeper := oraclekeeper.NewKeeper( + runtime.NewKVStoreService(keys[oracletypes.StoreKey]), + appCodec, + authtypes.NewModuleAddress(govtypes.ModuleName), + ) + + msgRouter := baseapp.NewMsgServiceRouter() + msgRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry) + queryRouter := baseapp.NewGRPCQueryRouter() + queryRouter.SetInterfaceRegistry(encodingConfig.InterfaceRegistry) + + queryAllowlist := make(map[string]proto.Message) + queryAllowlist["/slinky.oracle.v1.Query/GetAllCurrencyPairs"] = &oracletypes.GetAllCurrencyPairsResponse{} + queryAllowlist["/slinky.oracle.v1.Query/GetPrice"] = &oracletypes.GetPriceResponse{} + queryAllowlist["/slinky.oracle.v1.Query/GetPrices"] = &oracletypes.GetPricesResponse{} + + // use accept list stargate querier + wasmOpts := []wasmkeeper.Option{} + wasmOpts = append(wasmOpts, wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{ + Stargate: wasmkeeper.AcceptListStargateQuerier(queryAllowlist, queryRouter, appCodec), + })) + + wasmKeeper := wasmkeeper.NewKeeper( + appCodec, + runtime.NewKVStoreService(keys[wasmtypes.StoreKey]), + accountKeeper, + bankKeeper, + nil, + nil, + nil, + nil, + nil, + nil, + nil, + msgRouter, + queryRouter, + t.TempDir(), + wasmtypes.DefaultWasmConfig(), + "iterator,stargate,cosmwasm_1_1,cosmwasm_1_2,cosmwasm_1_3,cosmwasm_1_4", + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + wasmOpts..., + ) + wasmParams := wasmtypes.DefaultParams() + require.NoError(t, wasmKeeper.SetParams(ctx, wasmParams)) + + faucet := NewTestFaucet(t, ctx, bankKeeper, authtypes.Minter, initialTotalSupply()...) + + // register query service + am := module.NewManager( // minimal module set that we use for message/ query tests + oracle.NewAppModule(appCodec, oracleKeeper), + ) + am.RegisterServices(module.NewConfigurator(appCodec, msgRouter, queryRouter)) //nolint:errcheck + + keepers := TestKeepers{ + AccountKeeper: accountKeeper, + WasmKeeper: wasmKeeper, + BankKeeper: bankKeeper, + OracleKeeper: oracleKeeper, + EncodingConfig: encodingConfig, + Faucet: faucet, + MultiStore: ms, + } + return ctx, keepers +} diff --git a/app/wasmtesting/contracts b/app/wasmtesting/contracts new file mode 160000 index 0000000..27ff87e --- /dev/null +++ b/app/wasmtesting/contracts @@ -0,0 +1 @@ +Subproject commit 27ff87e971bed2522fc3dcd47a5a1f427f76bf53 diff --git a/app/wasmtesting/stargate_test.go b/app/wasmtesting/stargate_test.go new file mode 100644 index 0000000..40aa027 --- /dev/null +++ b/app/wasmtesting/stargate_test.go @@ -0,0 +1,54 @@ +package wasm_hooks_test + +import ( + "os" + "testing" + + wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper" + wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/stretchr/testify/require" + + oracletypes "github.com/skip-mev/slinky/x/oracle/types" +) + +func Test_StargateQuery(t *testing.T) { + ctx, input := createDefaultTestInput(t) + _, _, addr := keyPubAddr() + + code, err := os.ReadFile("./contracts/artifacts/slinky.wasm") + require.NoError(t, err) + + wasmMsgServer := wasmkeeper.NewMsgServerImpl(&input.WasmKeeper) + storeRes, err := wasmMsgServer.StoreCode(ctx, &wasmtypes.MsgStoreCode{ + Sender: addr.String(), + WASMByteCode: code, + }) + require.NoError(t, err) + + instantiateRes, err := wasmMsgServer.InstantiateContract(ctx, &wasmtypes.MsgInstantiateContract{ + Sender: addr.String(), + Admin: addr.String(), + CodeID: storeRes.CodeID, + Label: "Slinky", + Msg: []byte("{}"), + Funds: nil, + }) + require.NoError(t, err) + + contractAddrBech32 := instantiateRes.Address + contractAddr, err := sdk.AccAddressFromBech32(contractAddrBech32) + require.NoError(t, err) + + err = input.OracleKeeper.CreateCurrencyPair(ctx, oracletypes.CurrencyPair{ + Base: "BITCOIN", + Quote: "USD", + }) + require.NoError(t, err) + + res, err := input.WasmKeeper.QuerySmart(ctx, contractAddr, []byte(`{"get_all_currency_pairs": {}}`)) + require.NoError(t, err) + require.Equal(t, "{\"currency_pairs\":[{\"Base\":\"BITCOIN\",\"Quote\":\"USD\"}]}", string(res)) +} From 8c47da254470fa5d6d39620f9007a2392a3a2416 Mon Sep 17 00:00:00 2001 From: beer-1 <147697694+beer-1@users.noreply.github.com> Date: Sun, 7 Apr 2024 13:03:54 +0900 Subject: [PATCH 2/2] remove submodule --- app/wasmtesting/contracts | 1 - app/wasmtesting/contracts/.cargo/config | 8 + app/wasmtesting/contracts/.gitignore | 13 + app/wasmtesting/contracts/Cargo.lock | 1016 +++++++++++++++++ app/wasmtesting/contracts/Cargo.toml | 33 + app/wasmtesting/contracts/README.md | 1 + .../contracts/artifacts/slinky.wasm | Bin 0 -> 199722 bytes app/wasmtesting/contracts/build.rs | 43 + app/wasmtesting/contracts/mod.rs | 3 + app/wasmtesting/contracts/src/execute.rs | 28 + app/wasmtesting/contracts/src/lib.rs | 54 + app/wasmtesting/contracts/src/mod.rs | 3 + app/wasmtesting/contracts/src/msgs.rs | 21 + .../contracts/src/protos/slinky.proto | 11 + app/wasmtesting/contracts/src/query.rs | 41 + app/wasmtesting/contracts/src/slinky.rs | 437 +++++++ app/wasmtesting/contracts/src/state.rs | 13 + 17 files changed, 1725 insertions(+), 1 deletion(-) delete mode 160000 app/wasmtesting/contracts create mode 100644 app/wasmtesting/contracts/.cargo/config create mode 100644 app/wasmtesting/contracts/.gitignore create mode 100644 app/wasmtesting/contracts/Cargo.lock create mode 100644 app/wasmtesting/contracts/Cargo.toml create mode 100644 app/wasmtesting/contracts/README.md create mode 100755 app/wasmtesting/contracts/artifacts/slinky.wasm create mode 100644 app/wasmtesting/contracts/build.rs create mode 100644 app/wasmtesting/contracts/mod.rs create mode 100644 app/wasmtesting/contracts/src/execute.rs create mode 100644 app/wasmtesting/contracts/src/lib.rs create mode 100644 app/wasmtesting/contracts/src/mod.rs create mode 100644 app/wasmtesting/contracts/src/msgs.rs create mode 100644 app/wasmtesting/contracts/src/protos/slinky.proto create mode 100644 app/wasmtesting/contracts/src/query.rs create mode 100644 app/wasmtesting/contracts/src/slinky.rs create mode 100644 app/wasmtesting/contracts/src/state.rs diff --git a/app/wasmtesting/contracts b/app/wasmtesting/contracts deleted file mode 160000 index 27ff87e..0000000 --- a/app/wasmtesting/contracts +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 27ff87e971bed2522fc3dcd47a5a1f427f76bf53 diff --git a/app/wasmtesting/contracts/.cargo/config b/app/wasmtesting/contracts/.cargo/config new file mode 100644 index 0000000..e48917b --- /dev/null +++ b/app/wasmtesting/contracts/.cargo/config @@ -0,0 +1,8 @@ +[alias] +wasm = "build --release --target wasm32-unknown-unknown" +wasm-debug = "build --target wasm32-unknown-unknown" +unit-test = "test --lib" +schema = "run --example schema" + +[build] +rustflags = ["-C", "link-args=-s"] \ No newline at end of file diff --git a/app/wasmtesting/contracts/.gitignore b/app/wasmtesting/contracts/.gitignore new file mode 100644 index 0000000..4de6211 --- /dev/null +++ b/app/wasmtesting/contracts/.gitignore @@ -0,0 +1,13 @@ +# macOS +.DS_Store + +# Text file backups +**/*.rs.bk + +# Build results +target/ + +# IDEs +.vscode/ +.idea/ +*.iml diff --git a/app/wasmtesting/contracts/Cargo.lock b/app/wasmtesting/contracts/Cargo.lock new file mode 100644 index 0000000..a7e8c29 --- /dev/null +++ b/app/wasmtesting/contracts/Cargo.lock @@ -0,0 +1,1016 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ahash" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "anyhow" +version = "1.0.81" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247" + +[[package]] +name = "autocfg" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" + +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + +[[package]] +name = "base64" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9" + +[[package]] +name = "base64ct" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" + +[[package]] +name = "bech32" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445" + +[[package]] +name = "bitflags" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" + +[[package]] +name = "block-buffer" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bnum" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "128a44527fc0d6abf05f9eda748b9027536e12dff93f5acc8449f51583309350" + +[[package]] +name = "byteorder" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" + +[[package]] +name = "bytes" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "const-oid" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28c122c3980598d243d63d9a704629a2d748d101f278052ff068be5a4423ab6f" + +[[package]] +name = "cosmwasm-crypto" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8bb3c77c3b7ce472056968c745eb501c440fbc07be5004eba02782c35bfbbe3" +dependencies = [ + "digest 0.10.7", + "ecdsa", + "ed25519-zebra", + "k256", + "rand_core 0.6.4", + "thiserror", +] + +[[package]] +name = "cosmwasm-derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea73e9162e6efde00018d55ed0061e93a108b5d6ec4548b4f8ce3c706249687" +dependencies = [ + "syn 1.0.98", +] + +[[package]] +name = "cosmwasm-schema" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0df41ea55f2946b6b43579659eec048cc2f66e8c8e2e3652fc5e5e476f673856" +dependencies = [ + "cosmwasm-schema-derive", + "schemars", + "serde", + "serde_json", + "thiserror", +] + +[[package]] +name = "cosmwasm-schema-derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43609e92ce1b9368aa951b334dd354a2d0dd4d484931a5f83ae10e12a26c8ba9" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.98", +] + +[[package]] +name = "cosmwasm-std" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04d6864742e3a7662d024b51a94ea81c9af21db6faea2f9a6d2232bb97c6e53e" +dependencies = [ + "base64", + "bech32", + "bnum", + "cosmwasm-crypto", + "cosmwasm-derive", + "derivative", + "forward_ref", + "hex", + "schemars", + "serde", + "serde-json-wasm", + "sha2 0.10.8", + "static_assertions", + "thiserror", +] + +[[package]] +name = "cpufeatures" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-bigint" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28f85c3514d2a6e64160359b45a3918c3b4178bcbf4ae5d03ab2d02e521c479a" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "curve25519-dalek" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" +dependencies = [ + "byteorder", + "digest 0.9.0", + "rand_core 0.5.1", + "subtle", + "zeroize", +] + +[[package]] +name = "der" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c" +dependencies = [ + "const-oid", + "zeroize", +] + +[[package]] +name = "derivative" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.98", +] + +[[package]] +name = "digest" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066" +dependencies = [ + "generic-array", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "const-oid", + "crypto-common", + "subtle", +] + +[[package]] +name = "dyn-clone" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "140206b78fb2bc3edbcfc9b5ccbd0b30699cfe8d348b8b31b330e47df5291a5a" + +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der", + "digest 0.10.7", + "elliptic-curve", + "rfc6979", + "signature", + "spki", +] + +[[package]] +name = "ed25519-zebra" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6" +dependencies = [ + "curve25519-dalek", + "hashbrown", + "hex", + "rand_core 0.6.4", + "serde", + "sha2 0.9.9", + "zeroize", +] + +[[package]] +name = "either" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a" + +[[package]] +name = "elliptic-curve" +version = "0.13.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9775b22bc152ad86a0cf23f0f348b884b26add12bf741e7ffc4d4ab2ab4d205" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest 0.10.7", + "ff", + "generic-array", + "group", + "pkcs8", + "rand_core 0.6.4", + "sec1", + "subtle", + "zeroize", +] + +[[package]] +name = "errno" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" +dependencies = [ + "libc", + "windows-sys", +] + +[[package]] +name = "fastrand" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984" + +[[package]] +name = "ff" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" +dependencies = [ + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "forward_ref" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8cbd1169bd7b4a0a20d92b9af7a7e0422888bd38a6f5ec29c1fd8c1558a272e" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", + "zeroize", +] + +[[package]] +name = "getrandom" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +dependencies = [ + "ahash", +] + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest 0.10.7", +] + +[[package]] +name = "home" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "indexmap" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d" + +[[package]] +name = "k256" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f01b677d82ef7a676aa37e099defd83a28e15687112cafdd112d60236b6115b" +dependencies = [ + "cfg-if", + "ecdsa", + "elliptic-curve", + "once_cell", + "sha2 0.10.8", + "signature", +] + +[[package]] +name = "libc" +version = "0.2.153" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" + +[[package]] +name = "linux-raw-sys" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c" + +[[package]] +name = "log" +version = "0.4.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" + +[[package]] +name = "memchr" +version = "2.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" + +[[package]] +name = "once_cell" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" + +[[package]] +name = "opaque-debug" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" + +[[package]] +name = "pkcs8" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" +dependencies = [ + "der", + "spki", +] + +[[package]] +name = "proc-macro2" +version = "1.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "protobuf" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58678a64de2fced2bdec6bca052a6716a0efe692d6e3f53d1bda6a1def64cfc0" +dependencies = [ + "bytes", + "once_cell", + "protobuf-support", + "thiserror", +] + +[[package]] +name = "protobuf-codegen" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32777b0b3f6538d9d2e012b3fad85c7e4b9244b5958d04a6415f4333782b7a77" +dependencies = [ + "anyhow", + "once_cell", + "protobuf", + "protobuf-parse", + "regex", + "tempfile", + "thiserror", +] + +[[package]] +name = "protobuf-parse" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96cb37955261126624a25b5e6bda40ae34cf3989d52a783087ca6091b29b5642" +dependencies = [ + "anyhow", + "indexmap", + "log", + "protobuf", + "protobuf-support", + "tempfile", + "thiserror", + "which", +] + +[[package]] +name = "protobuf-support" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1ed294a835b0f30810e13616b1cd34943c6d1e84a8f3b0dcfe466d256c3e7e7" +dependencies = [ + "thiserror", +] + +[[package]] +name = "protoc-bin-vendored" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "005ca8623e5633e298ad1f917d8be0a44bcf406bf3cde3b80e63003e49a3f27d" +dependencies = [ + "protoc-bin-vendored-linux-aarch_64", + "protoc-bin-vendored-linux-ppcle_64", + "protoc-bin-vendored-linux-x86_32", + "protoc-bin-vendored-linux-x86_64", + "protoc-bin-vendored-macos-x86_64", + "protoc-bin-vendored-win32", +] + +[[package]] +name = "protoc-bin-vendored-linux-aarch_64" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fb9fc9cce84c8694b6ea01cc6296617b288b703719b725b8c9c65f7c5874435" + +[[package]] +name = "protoc-bin-vendored-linux-ppcle_64" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02d2a07dcf7173a04d49974930ccbfb7fd4d74df30ecfc8762cf2f895a094516" + +[[package]] +name = "protoc-bin-vendored-linux-x86_32" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d54fef0b04fcacba64d1d80eed74a20356d96847da8497a59b0a0a436c9165b0" + +[[package]] +name = "protoc-bin-vendored-linux-x86_64" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8782f2ce7d43a9a5c74ea4936f001e9e8442205c244f7a3d4286bd4c37bc924" + +[[package]] +name = "protoc-bin-vendored-macos-x86_64" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5de656c7ee83f08e0ae5b81792ccfdc1d04e7876b1d9a38e6876a9e09e02537" + +[[package]] +name = "protoc-bin-vendored-win32" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9653c3ed92974e34c5a6e0a510864dab979760481714c172e0a34e437cb98804" + +[[package]] +name = "quote" +version = "1.0.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "regex" +version = "1.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" + +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac", + "subtle", +] + +[[package]] +name = "rustix" +version = "0.38.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys", +] + +[[package]] +name = "ryu" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695" + +[[package]] +name = "schemars" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1847b767a3d62d95cbf3d8a9f0e421cf57a0d8aa4f411d4b16525afb0284d4ed" +dependencies = [ + "dyn-clone", + "schemars_derive", + "serde", + "serde_json", +] + +[[package]] +name = "schemars_derive" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af4d7e1b012cb3d9129567661a63755ea4b8a7386d339dc945ae187e403c6743" +dependencies = [ + "proc-macro2", + "quote", + "serde_derive_internals", + "syn 1.0.98", +] + +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "pkcs8", + "subtle", + "zeroize", +] + +[[package]] +name = "serde" +version = "1.0.137" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61ea8d54c77f8315140a05f4c7237403bf38b72704d031543aa1d16abbf517d1" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde-json-wasm" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16a62a1fad1e1828b24acac8f2b468971dade7b8c3c2e672bcadefefb1f8c137" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_derive" +version = "1.0.137" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f26faba0c3959972377d3b2d306ee9f71faee9714294e41bb777f83f88578be" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.98", +] + +[[package]] +name = "serde_derive_internals" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.98", +] + +[[package]] +name = "serde_json" +version = "1.0.81" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b7ce2b32a1aed03c558dc61a5cd328f15aff2dbc17daad8fb8af04d2100e15c" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sha2" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" +dependencies = [ + "block-buffer 0.9.0", + "cfg-if", + "cpufeatures", + "digest 0.9.0", + "opaque-debug", +] + +[[package]] +name = "sha2" +version = "0.10.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest 0.10.7", +] + +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest 0.10.7", + "rand_core 0.6.4", +] + +[[package]] +name = "slinky" +version = "0.0.1" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "protobuf", + "protobuf-codegen", + "protoc-bin-vendored", + "schemars", + "serde", + "thiserror", +] + +[[package]] +name = "spki" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a" +dependencies = [ + "base64ct", + "der", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "subtle" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601" + +[[package]] +name = "syn" +version = "1.0.98" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tempfile" +version = "3.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" +dependencies = [ + "cfg-if", + "fastrand", + "rustix", + "windows-sys", +] + +[[package]] +name = "thiserror" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "typenum" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" + +[[package]] +name = "unicode-ident" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "which" +version = "4.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" +dependencies = [ + "either", + "home", + "once_cell", + "rustix", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8" + +[[package]] +name = "zeroize" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" diff --git a/app/wasmtesting/contracts/Cargo.toml b/app/wasmtesting/contracts/Cargo.toml new file mode 100644 index 0000000..202f187 --- /dev/null +++ b/app/wasmtesting/contracts/Cargo.toml @@ -0,0 +1,33 @@ +[package] +name = "slinky" +version = "0.0.1" +authors = ["alapc"] +edition = "2021" +description = "" +license = "" +repository = "" +build = "build.rs" + +[lib] +crate-type = ["cdylib", "rlib"] + +[features] +# for more explicit tests, cargo test --features=backtraces +backtraces = ["cosmwasm-std/backtraces"] +# use library feature to disable all instantiate/execute/query exports +library = [] + +[dependencies] +cosmwasm-std = { version = "1.5.0", features = ["stargate"] } +schemars = "0.8.1" +serde = { version = "1.0.103", default-features = false, features = ["derive"] } +thiserror = { version = "1.0.23" } +protobuf = { version = "3.4", features = ["with-bytes"] } + +[dev-dependencies] +cosmwasm-schema = { version = "1.5.0" } + +[build-dependencies] +protobuf-codegen = "3.4" +protoc-bin-vendored = "3" +protobuf = { version = "3.4" } diff --git a/app/wasmtesting/contracts/README.md b/app/wasmtesting/contracts/README.md new file mode 100644 index 0000000..7d67b7e --- /dev/null +++ b/app/wasmtesting/contracts/README.md @@ -0,0 +1 @@ +# Test wasm stargate diff --git a/app/wasmtesting/contracts/artifacts/slinky.wasm b/app/wasmtesting/contracts/artifacts/slinky.wasm new file mode 100755 index 0000000000000000000000000000000000000000..6eee107342febccfd270ae7c93dc0256eca94d1c GIT binary patch literal 199722 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 M%mMjn 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 Ta-t7$bdc8o_X3XrKL!2^dpZxa literal 0 HcmV?d00001 diff --git a/app/wasmtesting/contracts/build.rs b/app/wasmtesting/contracts/build.rs new file mode 100644 index 0000000..edc2589 --- /dev/null +++ b/app/wasmtesting/contracts/build.rs @@ -0,0 +1,43 @@ +use protobuf_codegen::{Codegen, Customize, CustomizeCallback}; +use protoc_bin_vendored; +use protobuf::descriptor::field_descriptor_proto::Type; +use protobuf::reflect::FieldDescriptor; +use protobuf::reflect::MessageDescriptor; + +fn main() { + struct GenSerde; + + impl CustomizeCallback for GenSerde { + fn message(&self, _message: &MessageDescriptor) -> Customize { + Customize::default().before("#[derive(::serde::Serialize, ::serde::Deserialize)]") + } + + fn field(&self, field: &FieldDescriptor) -> Customize { + if field.proto().type_() == Type::TYPE_ENUM { + // `EnumOrUnknown` is not a part of rust-protobuf, so external serializer is needed. + Customize::default().before( + "#[serde(serialize_with = \"crate::serialize_enum_or_unknown\", deserialize_with = \"crate::deserialize_enum_or_unknown\")]") + } else { + Customize::default() + } + } + + fn special_field(&self, _message: &MessageDescriptor, _field: &str) -> Customize { + Customize::default().before("#[serde(skip)]") + } + } + + Codegen::new() + // Use `protoc` parser, optional. + .protoc() + // Use `protoc-bin-vendored` bundled protoc command, optional. + .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap()) + // All inputs and imports from the inputs must reside in `includes` directories. + .includes(&["src/protos"]) + // Inputs must reside in some of include paths. + .input("src/protos/slinky.proto") + // Specify output directory relative to Cargo output directory. + .out_dir("src/") + .customize_callback(GenSerde) + .run_from_script(); +} diff --git a/app/wasmtesting/contracts/mod.rs b/app/wasmtesting/contracts/mod.rs new file mode 100644 index 0000000..0e5240f --- /dev/null +++ b/app/wasmtesting/contracts/mod.rs @@ -0,0 +1,3 @@ +// @generated + +pub mod slinky; diff --git a/app/wasmtesting/contracts/src/execute.rs b/app/wasmtesting/contracts/src/execute.rs new file mode 100644 index 0000000..6b95d68 --- /dev/null +++ b/app/wasmtesting/contracts/src/execute.rs @@ -0,0 +1,28 @@ +use cosmwasm_std::{DepsMut, Env, MessageInfo, Response, StdResult}; +use crate::msgs::{InstantiateMsg, ExecuteMsg}; +use crate::state::Contract; + +impl<'a> Contract { + pub fn instantiate( + &self, + _deps: DepsMut, + _env: Env, + _info: MessageInfo, + _msg: InstantiateMsg + ) -> StdResult { + Ok(Response::new()) + } + + pub fn execute( + &self, + _deps: DepsMut, + _env: Env, + _info: MessageInfo, + msg: ExecuteMsg + ) -> StdResult { + match msg { + ExecuteMsg::Foo {} + => Ok(Response::new()) + } + } +} diff --git a/app/wasmtesting/contracts/src/lib.rs b/app/wasmtesting/contracts/src/lib.rs new file mode 100644 index 0000000..227059d --- /dev/null +++ b/app/wasmtesting/contracts/src/lib.rs @@ -0,0 +1,54 @@ +mod execute; +mod state; +mod msgs; +mod query; +mod slinky; + +use crate::msgs::{InstantiateMsg, ExecuteMsg, + // QueryMsg, MigrateMsg +}; +use crate::state::Contract; + +#[cfg(not(feature = "library"))] +pub mod entry { + use self::msgs::QueryMsg; + +use super::*; + + use cosmwasm_std::{entry_point, Binary, Deps, Empty}; + use cosmwasm_std::{DepsMut, Env, MessageInfo, Response, StdResult}; + + + #[entry_point] + pub fn instantiate( + deps: DepsMut, + env: Env, + info: MessageInfo, + msg: InstantiateMsg, + ) -> StdResult { + let tract = Contract::default(); + tract.instantiate(deps, env, info, msg) + } + + #[entry_point] + pub fn execute( + deps: DepsMut, + env: Env, + info: MessageInfo, + msg: ExecuteMsg, + ) -> StdResult { + let tract = Contract::default(); + tract.execute(deps, env, info, msg) + } + + #[entry_point] + pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult { + let tract = Contract::default(); + tract.query(deps, env, msg) + } + + #[entry_point] + pub fn migrate(_deps: DepsMut, _env: Env, _msg: Empty) -> StdResult { + Ok(Response::new()) + } +} diff --git a/app/wasmtesting/contracts/src/mod.rs b/app/wasmtesting/contracts/src/mod.rs new file mode 100644 index 0000000..0e5240f --- /dev/null +++ b/app/wasmtesting/contracts/src/mod.rs @@ -0,0 +1,3 @@ +// @generated + +pub mod slinky; diff --git a/app/wasmtesting/contracts/src/msgs.rs b/app/wasmtesting/contracts/src/msgs.rs new file mode 100644 index 0000000..65bd4ce --- /dev/null +++ b/app/wasmtesting/contracts/src/msgs.rs @@ -0,0 +1,21 @@ +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + + +#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)] +pub struct InstantiateMsg {} + +#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum ExecuteMsg { + Foo {}, +} + +#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)] +#[serde(rename_all = "snake_case")] +pub enum QueryMsg { + // GetPrice { + // pair_id: String + // }, + GetAllCurrencyPairs {}, +} diff --git a/app/wasmtesting/contracts/src/protos/slinky.proto b/app/wasmtesting/contracts/src/protos/slinky.proto new file mode 100644 index 0000000..6732f46 --- /dev/null +++ b/app/wasmtesting/contracts/src/protos/slinky.proto @@ -0,0 +1,11 @@ +syntax = "proto3"; + +message GetAllCurrencyPairsRequest {} +message GetAllCurrencyPairsResponse { + repeated CurrencyPair currency_pairs = 1; +} + +message CurrencyPair { + string Base = 1; + string Quote = 2; +} diff --git a/app/wasmtesting/contracts/src/query.rs b/app/wasmtesting/contracts/src/query.rs new file mode 100644 index 0000000..b479143 --- /dev/null +++ b/app/wasmtesting/contracts/src/query.rs @@ -0,0 +1,41 @@ +use cosmwasm_std::{to_json_binary, Binary, Deps, Empty, Env, QueryRequest, StdResult}; + +use crate::msgs::QueryMsg; +use crate::slinky::{GetAllCurrencyPairsRequest, GetAllCurrencyPairsResponse}; +use crate::state::Contract; +use protobuf::Message; + +impl<'a> Contract { + fn get_all_currency_pairs( + &self, + deps: Deps, + _env: Env, + ) -> StdResult { + let request = GetAllCurrencyPairsRequest { + special_fields: ::protobuf::SpecialFields::new(), + }; + let bytes = request.write_to_bytes().unwrap(); + + let data = Binary::from(bytes); + let request = QueryRequest::::Stargate { + path: "/slinky.oracle.v1.Query/GetAllCurrencyPairs".to_string(), + data, + }; + let response: GetAllCurrencyPairsResponse = deps.querier.query(&request)?; + Ok(response) + } +} + +impl<'a> Contract { + pub fn query(&self, deps: Deps, env: Env, msg: QueryMsg) -> StdResult { + match msg { + // QueryMsg::GetPrice { pair_id } => to_json_binary(&self.get_price(deps, env, pair_id)?), + // QueryMsg::GetPriceRaw { pair_id } => { + // to_json_binary(&self.get_price_raw(deps, env, pair_id)?) + // } + QueryMsg::GetAllCurrencyPairs {} => { + to_json_binary(&self.get_all_currency_pairs(deps, env)?) + } + } + } +} diff --git a/app/wasmtesting/contracts/src/slinky.rs b/app/wasmtesting/contracts/src/slinky.rs new file mode 100644 index 0000000..672250a --- /dev/null +++ b/app/wasmtesting/contracts/src/slinky.rs @@ -0,0 +1,437 @@ +// This file is generated by rust-protobuf 3.4.0. Do not edit +// .proto file is parsed by protoc 3.19.4 +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_results)] +#![allow(unused_mut)] + +//! Generated file from `slinky.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0; + +#[derive(::serde::Serialize, ::serde::Deserialize)] +// @@protoc_insertion_point(message:GetAllCurrencyPairsRequest) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct GetAllCurrencyPairsRequest { + // special fields + #[serde(skip)] + // @@protoc_insertion_point(special_field:GetAllCurrencyPairsRequest.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a GetAllCurrencyPairsRequest { + fn default() -> &'a GetAllCurrencyPairsRequest { + ::default_instance() + } +} + +impl GetAllCurrencyPairsRequest { + pub fn new() -> GetAllCurrencyPairsRequest { + ::std::default::Default::default() + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(0); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "GetAllCurrencyPairsRequest", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for GetAllCurrencyPairsRequest { + const NAME: &'static str = "GetAllCurrencyPairsRequest"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> GetAllCurrencyPairsRequest { + GetAllCurrencyPairsRequest::new() + } + + fn clear(&mut self) { + self.special_fields.clear(); + } + + fn default_instance() -> &'static GetAllCurrencyPairsRequest { + static instance: GetAllCurrencyPairsRequest = GetAllCurrencyPairsRequest { + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for GetAllCurrencyPairsRequest { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("GetAllCurrencyPairsRequest").unwrap()).clone() + } +} + +impl ::std::fmt::Display for GetAllCurrencyPairsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetAllCurrencyPairsRequest { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(::serde::Serialize, ::serde::Deserialize)] +// @@protoc_insertion_point(message:GetAllCurrencyPairsResponse) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct GetAllCurrencyPairsResponse { + // message fields + // @@protoc_insertion_point(field:GetAllCurrencyPairsResponse.currency_pairs) + pub currency_pairs: ::std::vec::Vec, + // special fields + #[serde(skip)] + // @@protoc_insertion_point(special_field:GetAllCurrencyPairsResponse.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a GetAllCurrencyPairsResponse { + fn default() -> &'a GetAllCurrencyPairsResponse { + ::default_instance() + } +} + +impl GetAllCurrencyPairsResponse { + pub fn new() -> GetAllCurrencyPairsResponse { + ::std::default::Default::default() + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(1); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "currency_pairs", + |m: &GetAllCurrencyPairsResponse| { &m.currency_pairs }, + |m: &mut GetAllCurrencyPairsResponse| { &mut m.currency_pairs }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "GetAllCurrencyPairsResponse", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for GetAllCurrencyPairsResponse { + const NAME: &'static str = "GetAllCurrencyPairsResponse"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.currency_pairs.push(is.read_message()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + for value in &self.currency_pairs { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + for v in &self.currency_pairs { + ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?; + }; + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> GetAllCurrencyPairsResponse { + GetAllCurrencyPairsResponse::new() + } + + fn clear(&mut self) { + self.currency_pairs.clear(); + self.special_fields.clear(); + } + + fn default_instance() -> &'static GetAllCurrencyPairsResponse { + static instance: GetAllCurrencyPairsResponse = GetAllCurrencyPairsResponse { + currency_pairs: ::std::vec::Vec::new(), + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for GetAllCurrencyPairsResponse { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("GetAllCurrencyPairsResponse").unwrap()).clone() + } +} + +impl ::std::fmt::Display for GetAllCurrencyPairsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetAllCurrencyPairsResponse { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(::serde::Serialize, ::serde::Deserialize)] +// @@protoc_insertion_point(message:CurrencyPair) +#[derive(PartialEq,Clone,Default,Debug)] +pub struct CurrencyPair { + // message fields + // @@protoc_insertion_point(field:CurrencyPair.Base) + pub Base: ::std::string::String, + // @@protoc_insertion_point(field:CurrencyPair.Quote) + pub Quote: ::std::string::String, + // special fields + #[serde(skip)] + // @@protoc_insertion_point(special_field:CurrencyPair.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a CurrencyPair { + fn default() -> &'a CurrencyPair { + ::default_instance() + } +} + +impl CurrencyPair { + pub fn new() -> CurrencyPair { + ::std::default::Default::default() + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( + "Base", + |m: &CurrencyPair| { &m.Base }, + |m: &mut CurrencyPair| { &mut m.Base }, + )); + fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( + "Quote", + |m: &CurrencyPair| { &m.Quote }, + |m: &mut CurrencyPair| { &mut m.Quote }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "CurrencyPair", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for CurrencyPair { + const NAME: &'static str = "CurrencyPair"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.Base = is.read_string()?; + }, + 18 => { + self.Quote = is.read_string()?; + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if !self.Base.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.Base); + } + if !self.Quote.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.Quote); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if !self.Base.is_empty() { + os.write_string(1, &self.Base)?; + } + if !self.Quote.is_empty() { + os.write_string(2, &self.Quote)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> CurrencyPair { + CurrencyPair::new() + } + + fn clear(&mut self) { + self.Base.clear(); + self.Quote.clear(); + self.special_fields.clear(); + } + + fn default_instance() -> &'static CurrencyPair { + static instance: CurrencyPair = CurrencyPair { + Base: ::std::string::String::new(), + Quote: ::std::string::String::new(), + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for CurrencyPair { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("CurrencyPair").unwrap()).clone() + } +} + +impl ::std::fmt::Display for CurrencyPair { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CurrencyPair { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x0cslinky.proto\"\x1c\n\x1aGetAllCurrencyPairsRequest\"S\n\x1bGetAllC\ + urrencyPairsResponse\x124\n\x0ecurrency_pairs\x18\x01\x20\x03(\x0b2\r.Cu\ + rrencyPairR\rcurrencyPairs\"8\n\x0cCurrencyPair\x12\x12\n\x04Base\x18\ + \x01\x20\x01(\tR\x04Base\x12\x14\n\x05Quote\x18\x02\x20\x01(\tR\x05Quote\ + b\x06proto3\ +"; + +/// `FileDescriptorProto` object which was a source for this generated file +fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new(); + file_descriptor_proto_lazy.get(|| { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() + }) +} + +/// `FileDescriptor` object which allows dynamic access to files +pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor { + static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new(); + static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new(); + file_descriptor.get(|| { + let generated_file_descriptor = generated_file_descriptor_lazy.get(|| { + let mut deps = ::std::vec::Vec::with_capacity(0); + let mut messages = ::std::vec::Vec::with_capacity(3); + messages.push(GetAllCurrencyPairsRequest::generated_message_descriptor_data()); + messages.push(GetAllCurrencyPairsResponse::generated_message_descriptor_data()); + messages.push(CurrencyPair::generated_message_descriptor_data()); + let mut enums = ::std::vec::Vec::with_capacity(0); + ::protobuf::reflect::GeneratedFileDescriptor::new_generated( + file_descriptor_proto(), + deps, + messages, + enums, + ) + }); + ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor) + }) +} diff --git a/app/wasmtesting/contracts/src/state.rs b/app/wasmtesting/contracts/src/state.rs new file mode 100644 index 0000000..56929c7 --- /dev/null +++ b/app/wasmtesting/contracts/src/state.rs @@ -0,0 +1,13 @@ +pub struct Contract {} + +impl Default for Contract { + fn default() -> Self { + Self::new() + } +} + +impl<'a> Contract { + fn new() -> Self { + Self {} + } +}