diff --git a/.github/workflows/interchaintest.yml b/.github/workflows/interchaintest.yml index 2febd9bdd..22731c0d5 100644 --- a/.github/workflows/interchaintest.yml +++ b/.github/workflows/interchaintest.yml @@ -23,7 +23,7 @@ jobs: with: registry: ghcr.io username: ${{ github.repository_owner }} - password: ${{ secrets.GITHUB_TOKEN }} + password: ${{ secrets.GHCR_PAT }} - name: Build and push id: build_push_image uses: docker/build-push-action@v3 diff --git a/.gitignore b/.gitignore index e31ef07c1..86bceed62 100644 --- a/.gitignore +++ b/.gitignore @@ -29,7 +29,8 @@ dist/ # Test binary, built with `go test -c` *.test - +# Test data +data/* # Output of the go coverage tool, specifically when used with LiteIDE *.out @@ -48,8 +49,11 @@ vendor go.work go.work.sum +_build/ -_build +mytestnet/ screenlog.0 -mytestnet \ No newline at end of file +.idea +node_modules + diff --git a/.goreleaser.yml b/.goreleaser.yml index 181b7e9ea..b185486fd 100644 --- a/.goreleaser.yml +++ b/.goreleaser.yml @@ -1,14 +1,14 @@ # .goreleaser.yml -project_name: centaurid +project_name: picad env: - CGO_ENABLED=1 builds: - id: linux - main: ./cmd/centaurid - binary: centaurid + main: ./cmd/picad + binary: picad hooks: pre: - cmd: bash scripts/release_pre_linux.sh @@ -28,8 +28,8 @@ builds: - -mod=readonly - -trimpath ldflags: - - -X github.com/cosmos/cosmos-sdk/version.Name=centauri - - -X github.com/cosmos/cosmos-sdk/version.AppName=centaurid + - -X github.com/cosmos/cosmos-sdk/version.Name=pica + - -X github.com/cosmos/cosmos-sdk/version.AppName=picad - -X github.com/cosmos/cosmos-sdk/version.Version={{ .Version }} - -X github.com/cosmos/cosmos-sdk/version.Commit={{ .Commit }} - -X "github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger,muslc" diff --git a/Dockerfile b/Dockerfile index 6598b8e1a..cf3357ca3 100644 --- a/Dockerfile +++ b/Dockerfile @@ -18,7 +18,7 @@ RUN apk add --no-cache \ linux-headers # Download go dependencies -WORKDIR /centauri +WORKDIR /pica COPY go.mod go.sum ./ RUN --mount=type=cache,target=/root/.cache/go-build \ --mount=type=cache,target=/root/go/pkg/mod \ @@ -36,22 +36,22 @@ RUN set -eux; \ # Copy the remaining files COPY . . -# Build centaurid binary +# Build picad binary RUN --mount=type=cache,target=/root/.cache/go-build \ --mount=type=cache,target=/root/go/pkg/mod \ GOWORK=off go build \ -mod=readonly \ -tags "netgo,ledger,muslc" \ -ldflags \ - "-X github.com/cosmos/cosmos-sdk/version.Name="centauri" \ - -X github.com/cosmos/cosmos-sdk/version.AppName="centaurid" \ + "-X github.com/cosmos/cosmos-sdk/version.Name="pica" \ + -X github.com/cosmos/cosmos-sdk/version.AppName="picad" \ -X github.com/cosmos/cosmos-sdk/version.Version=${GIT_VERSION} \ -X github.com/cosmos/cosmos-sdk/version.Commit=${GIT_COMMIT} \ -X github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger,muslc \ -w -s -linkmode=external -extldflags '-Wl,-z,muldefs -static'" \ -trimpath \ - -o /centauri/build/centaurid \ - /centauri/cmd/centaurid + -o /pica/build/picad \ + /pica/cmd/picad # -------------------------------------------------------- @@ -59,7 +59,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \ # -------------------------------------------------------- FROM busybox:1.35.0-uclibc as busybox -RUN addgroup --gid 1025 -S composable && adduser --uid 1025 -S composable -G composable +RUN addgroup --gid 1025 -S pica && adduser --uid 1025 -S pica -G pica # -------------------------------------------------------- @@ -69,14 +69,14 @@ FROM ${RUNNER_IMAGE} COPY --from=busybox:1.35.0-uclibc /bin/sh /bin/sh -COPY --from=builder /centauri/build/centaurid /bin/centaurid +COPY --from=builder /pica/build/picad /bin/picad # Install composable user COPY --from=busybox /etc/passwd /etc/passwd -COPY --from=busybox --chown=1025:1025 /home/composable /home/composable +COPY --from=busybox --chown=1025:1025 /home/pica /home/pica -WORKDIR /home/composable -USER composable +WORKDIR /home/pica +USER pica # rest server EXPOSE 1317 @@ -87,4 +87,4 @@ EXPOSE 26657 # grpc EXPOSE 9090 -ENTRYPOINT ["centaurid"] \ No newline at end of file +ENTRYPOINT ["picad"] \ No newline at end of file diff --git a/Dockerfile.dev b/Dockerfile.dev index cd9684b2f..bebfd2810 100644 --- a/Dockerfile.dev +++ b/Dockerfile.dev @@ -18,7 +18,7 @@ RUN apk add --no-cache \ linux-headers # Download go dependencies -WORKDIR /centauri +WORKDIR /pica COPY go.mod go.sum ./ # Cosmwasm - Download correct libwasmvm version @@ -33,20 +33,20 @@ RUN set -eux; \ # Copy the remaining files COPY . . -# Build centaurid binary +# Build picad binary RUN GOWORK=off go build \ -mod=readonly \ -tags "netgo,ledger,muslc" \ -ldflags \ - "-X github.com/cosmos/cosmos-sdk/version.Name="centauri" \ - -X github.com/cosmos/cosmos-sdk/version.AppName="centaurid" \ + "-X github.com/cosmos/cosmos-sdk/version.Name="pica" \ + -X github.com/cosmos/cosmos-sdk/version.AppName="picad" \ -X github.com/cosmos/cosmos-sdk/version.Version=${GIT_VERSION} \ -X github.com/cosmos/cosmos-sdk/version.Commit=${GIT_COMMIT} \ -X github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger,muslc \ -w -s -linkmode=external -extldflags '-Wl,-z,muldefs -static'" \ -trimpath \ - -o /centauri/build/centaurid \ - /centauri/cmd/centaurid + -o /pica/build/picad \ + /pica/cmd/picad # -------------------------------------------------------- # Runner @@ -54,13 +54,13 @@ RUN GOWORK=off go build \ FROM ${RUNNER_IMAGE} -COPY --from=builder /centauri/build/centaurid /bin/centaurid +COPY --from=builder /pica/build/picad /bin/picad -ENV HOME /centauri +ENV HOME /pica WORKDIR $HOME -COPY scripts/* /centauri/ +COPY scripts/* /pica/ # rest server EXPOSE 1317 # tendermint p2p diff --git a/Makefile b/Makefile index 9aaac731e..ff3be81e1 100644 --- a/Makefile +++ b/Makefile @@ -58,8 +58,8 @@ comma := , build_tags_comma_sep := $(subst $(whitespace),$(comma),$(build_tags)) # process linker flags -ldflags = -X github.com/cosmos/cosmos-sdk/version.Name=centauri \ - -X github.com/cosmos/cosmos-sdk/version.AppName=centaurid \ +ldflags = -X github.com/cosmos/cosmos-sdk/version.Name=pica \ + -X github.com/cosmos/cosmos-sdk/version.AppName=picad \ -X github.com/cosmos/cosmos-sdk/version.Version=$(VERSION) \ -X github.com/cosmos/cosmos-sdk/version.Commit=$(COMMIT) \ -X "github.com/cosmos/cosmos-sdk/version.BuildTags=$(build_tags_comma_sep)" @@ -86,18 +86,18 @@ endif all: install install: go.sum - go install -mod=readonly $(BUILD_FLAGS) ./cmd/centaurid + go install -mod=readonly $(BUILD_FLAGS) ./cmd/picad build: - go build $(BUILD_FLAGS) -o bin/centaurid ./cmd/centaurid + go build $(BUILD_FLAGS) -o bin/picad ./cmd/picad docker-build-debug: - @DOCKER_BUILDKIT=1 docker build -t centauri:local -f Dockerfile . + @DOCKER_BUILDKIT=1 docker build -t centauri:debug -f Dockerfile . lint: @find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -name '*.pb.go' -not -name '*.gw.go' | xargs go run mvdan.cc/gofumpt -w . @find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -name '*.pb.go' -not -name '*.gw.go' | xargs go run github.com/client9/misspell/cmd/misspell -w - @find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -name '*.pb.go' -not -name '*.gw.go' | xargs go run golang.org/x/tools/cmd/goimports -w -local github.com/notional-labs/centauri + @find . -name '*.go' -type f -not -path "./vendor*" -not -path "*.git*" -not -name '*.pb.go' -not -name '*.gw.go' | xargs go run golang.org/x/tools/cmd/goimports -w -local github.com/notional-labs/pica .PHONY: lint ############################################################################### @@ -156,6 +156,21 @@ ictest-all: ictest-start-cosmos ictest-start-polkadot ictest-ibc ictest-push-wasm: cd tests/interchaintest && go test -race -v -run TestPushWasmClientCode . +# Init 2 cosmos chains and setup ibc between them +init-test-interchain: clean-testing-data install + ./scripts/test-upgrade-cosmos-chains.sh + +### Upgrade Test ### +test-upgrade: clean-testing-data + @echo "Starting upgrade test" + ./scripts/test-upgrade.sh + +clean-testing-data: + @echo "Killing binary and removing previous data" + -@pkill picad 2>/dev/null + -@pkill rly 2>/dev/null + -@rm -rf ./mytestnet + .PHONY: ictest-start-cosmos ictest-start-polkadot ictest-ibc ictest-push-wasm ictest-all include contrib/make/release.mk @@ -169,5 +184,28 @@ test-upgrade: clean-testing-data clean-testing-data: @echo "Killing binary and removing previous data" -@pkill centaurid 2>/dev/null + -@pkill picad 2>/dev/null + -@rm -rf ./screenlog.0 -@rm -rf ./mytestnet +## Scripts for testing sdk 50 +init-deps: + @echo "Installing dependencies" + bash ./scripts/upgrade/init-deps.sh + +localnet-pica: clean-testing-data + @echo "Starting localnet" + bash ./scripts/upgrade/setup-old-picad-node.sh + +localnet-picasso: + @echo "Starting localnet" + bash ./scripts/upgrade/setup-polkadot-node.sh + +relayer-start: + @echo "Starting relayer" + bash ./scripts/upgrade/setup-relayer.sh + +pica-upgrade: + @echo "Starting upgrade" + bash ./scripts/upgrade/upgrade.sh + diff --git a/README.md b/README.md index 9b8415a16..2cf032cb7 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Centauri +# Pica Cosmos blockchain with IBC-v7 and wasm client enable. ## Hardware Recommendation @@ -13,7 +13,7 @@ Requires [Go 1.20](https://go.dev/doc/install) or higher. ```bash make install -centaurid version +picad version ``` Then you can run a node with a single command. diff --git a/app/app.go b/app/app.go index 79a3acc4d..41705771e 100644 --- a/app/app.go +++ b/app/app.go @@ -7,7 +7,6 @@ import ( tmproto "github.com/cometbft/cometbft/proto/tendermint/types" runtimeservices "github.com/cosmos/cosmos-sdk/runtime/services" authcodec "github.com/cosmos/cosmos-sdk/x/auth/codec" - "github.com/notional-labs/composable/v6/app/upgrades/v6_5_1" "io" "os" "path/filepath" @@ -153,7 +152,7 @@ var ( // https://github.com/CosmWasm/wasmd/blob/02a54d33ff2c064f3539ae12d75d027d9c665f05/x/wasm/internal/types/proposal.go#L28-L34 EnableSpecificProposals = "" - Upgrades = []upgrades.Upgrade{v6_5_1.Upgrade, v7_0_1.Upgrade} + Upgrades = []upgrades.Upgrade{v7_0_1.Upgrade} Forks = []upgrades.Fork{} ) @@ -814,4 +813,4 @@ func (app *ComposableApp) AutoCliOpts() autocli.AppOptions { ValidatorAddressCodec: authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ValidatorAddrPrefix()), ConsensusAddressCodec: authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ConsensusAddrPrefix()), } -} +} \ No newline at end of file diff --git a/app/keepers/keepers.go b/app/keepers/keepers.go index faf05ef98..eca1fefe9 100644 --- a/app/keepers/keepers.go +++ b/app/keepers/keepers.go @@ -2,11 +2,12 @@ package keepers import ( "fmt" - "github.com/cosmos/cosmos-sdk/x/params" "math" "path/filepath" "strings" + "github.com/cosmos/cosmos-sdk/x/params" + circuitkeeper "cosmossdk.io/x/circuit/keeper" circuittypes "cosmossdk.io/x/circuit/types" icacontrollertypes "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/controller/types" @@ -121,7 +122,7 @@ import ( const ( AccountAddressPrefix = "composable" - authorityAddress = "centauri10556m38z4x6pqalr9rl5ytf3cff8q46nk85k9m" // convert from: centauri10556m38z4x6pqalr9rl5ytf3cff8q46nk85k9m + authorityAddress = "pica10556m38z4x6pqalr9rl5ytf3cff8q46nf36090" // convert from: centauri10556m38z4x6pqalr9rl5ytf3cff8q46nk85k9m ) type AppKeepers struct { @@ -211,12 +212,11 @@ func (appKeepers *AppKeepers) InitNormalKeepers( appKeepers.StakingMiddlewareKeeper = stakingmiddleware.NewKeeper(appCodec, appKeepers.keys[stakingmiddlewaretypes.StoreKey], govModAddress) appKeepers.IbcTransferMiddlewareKeeper = ibctransfermiddleware.NewKeeper(appCodec, appKeepers.keys[ibctransfermiddlewaretypes.StoreKey], govModAddress, - []string{"centauri1ay9y5uns9khw2kzaqr3r33v2pkuptfnnr93j5j", - "centauri14lz7gaw92valqjearnye4shex7zg2p05mlx9q0", - "centauri1r2zlh2xn85v8ljmwymnfrnsmdzjl7k6w6lytan", - "centauri10556m38z4x6pqalr9rl5ytf3cff8q46nk85k9m", - // "centauri1wkjvpgkuchq0r8425g4z4sf6n85zj5wtmqzjv9", - // "centauri1hj5fveer5cjtn4wd6wstzugjfdxzl0xpzxlwgs", + []string{ + "pica1ay9y5uns9khw2kzaqr3r33v2pkuptfnnunlt5x", + "pica14lz7gaw92valqjearnye4shex7zg2p05yfguqm", + "pica1r2zlh2xn85v8ljmwymnfrnsmdzjl7k6w9f2ja8", + "pica10556m38z4x6pqalr9rl5ytf3cff8q46nf36090", }) appKeepers.StakingKeeper = customstaking.NewKeeper( @@ -458,12 +458,16 @@ func (appKeepers *AppKeepers) InitNormalKeepers( vm, err := wasmvm.NewVM(wasmDataDir, wasmSupportedFeatures, wasmMemoryLimitMb, wasmPrintDebug, wasmCacheSizeMb) + if err != nil { + panic(err) + } + // use same VM for wasm appKeepers.Wasm08Keeper = wasm08Keeper.NewKeeperWithVM( appCodec, runtime.NewKVStoreService(appKeepers.keys[wasm08types.StoreKey]), &appKeepers.IBCKeeper.ClientKeeper, - "centauri1hj5fveer5cjtn4wd6wstzugjfdxzl0xpzxlwgs", + authorityAddress, vm, bApp.GRPCQueryRouter(), ) diff --git a/app/mock.go b/app/mock.go new file mode 100644 index 000000000..5a64b5348 --- /dev/null +++ b/app/mock.go @@ -0,0 +1,23 @@ +package app + +import ( + "github.com/cometbft/cometbft/crypto" + cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" +) + +// PV implements PrivValidator without any safety or persistence. +// Only use it for testing. +type PV struct { + PrivKey cryptotypes.PrivKey +} + +func NewPV() PV { + return PV{ed25519.GenPrivKey()} +} + +// GetPubKey implements PrivValidator interface +func (pv PV) GetPubKey() (crypto.PubKey, error) { + return cryptocodec.ToTmPubKeyInterface(pv.PrivKey.PubKey()) +} diff --git a/app/upgrades/v6_5_1/constants.go b/app/upgrades/v6_5_1/constants.go deleted file mode 100644 index 2189e34a4..000000000 --- a/app/upgrades/v6_5_1/constants.go +++ /dev/null @@ -1,20 +0,0 @@ -package v6_5_1 - -import ( - store "cosmossdk.io/store/types" - "github.com/notional-labs/composable/v6/app/upgrades" -) - -const ( - // UpgradeName defines the on-chain upgrade name for the composable upgrade. - UpgradeName = "v6_5_1" -) - -var Upgrade = upgrades.Upgrade{ - UpgradeName: UpgradeName, - CreateUpgradeHandler: CreateUpgradeHandler, - StoreUpgrades: store.StoreUpgrades{ - Added: []string{}, - Deleted: []string{}, - }, -} diff --git a/app/upgrades/v6_5_1/upgrade.go b/app/upgrades/v6_5_1/upgrade.go deleted file mode 100644 index 4de00e4f0..000000000 --- a/app/upgrades/v6_5_1/upgrade.go +++ /dev/null @@ -1,23 +0,0 @@ -package v6_5_1 - -import ( - "context" - upgradetypes "cosmossdk.io/x/upgrade/types" - "github.com/cosmos/cosmos-sdk/types/module" - - "github.com/cosmos/cosmos-sdk/codec" - "github.com/notional-labs/composable/v6/app/keepers" - "github.com/notional-labs/composable/v6/app/upgrades" -) - -func CreateUpgradeHandler( - mm *module.Manager, - configurator module.Configurator, - _ upgrades.BaseAppParamManager, - _ codec.Codec, - keepers *keepers.AppKeepers, -) upgradetypes.UpgradeHandler { - return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) { - return mm.RunMigrations(ctx, configurator, vm) - } -} diff --git a/bech32-migration/auth/auth.go b/bech32-migration/auth/auth.go deleted file mode 100644 index 614ac9bba..000000000 --- a/bech32-migration/auth/auth.go +++ /dev/null @@ -1,75 +0,0 @@ -package auth - -import ( - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - - storetypes "cosmossdk.io/store/types" - "github.com/cosmos/cosmos-sdk/x/auth/types" - vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types" - - "github.com/notional-labs/composable/v6/bech32-migration/utils" -) - -func MigrateAddressBech32(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec) { - ctx.Logger().Info("Migration of address bech32 for auth module begin") - migratedAccountCount := uint64(0) - migratedAccountTypesStat := map[string]uint64{} - utils.IterateStoreByPrefix(ctx, storeKey, types.AddressStoreKeyPrefix, func(bz []byte) []byte { - var accountI types.AccountI - err := cdc.UnmarshalInterface(bz, &accountI) - if err != nil { - panic(err) - } - switch acci := accountI.(type) { - case *types.BaseAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["BaseAccount"]++ - case *types.ModuleAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["ModuleAccount"]++ - case *vestingtypes.BaseVestingAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["BaseVestingAccount"]++ - case *vestingtypes.ContinuousVestingAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["ContinuousVestingAccount"]++ - case *vestingtypes.DelayedVestingAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["DelayedVestingAccount"]++ - case *vestingtypes.PeriodicVestingAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["PeriodicVestingAccount"]++ - case *vestingtypes.PermanentLockedAccount: - acc := acci - acc.Address = utils.ConvertAccAddr(acc.Address) - migratedAccountTypesStat["PermanentLockedAccount"]++ - default: - ctx.Logger().Info( - "Warning: unknown account type, skipping migration", - "address", accountI.GetAddress().String(), - "account_number", accountI.GetAccountNumber(), - "public_key", accountI.GetPubKey(), - "sequence", accountI.GetSequence(), - ) - return bz - } - bz, err = cdc.MarshalInterface(accountI) - if err != nil { - panic(err) - } - migratedAccountCount++ - return bz - }) - ctx.Logger().Info( - "Migration of address bech32 for auth module done", - "migrated_account_count", migratedAccountCount, - "migrated_account_types_stat", migratedAccountTypesStat, - ) -} diff --git a/bech32-migration/gov/gov.go b/bech32-migration/gov/gov.go deleted file mode 100644 index b95f0f945..000000000 --- a/bech32-migration/gov/gov.go +++ /dev/null @@ -1,47 +0,0 @@ -package gov - -import ( - storetypes "cosmossdk.io/store/types" - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - - "github.com/cosmos/cosmos-sdk/x/gov/types" - v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" - "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" - - "github.com/notional-labs/composable/v6/bech32-migration/utils" -) - -func MigrateAddressBech32(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec) { - ctx.Logger().Info("Migration of address bech32 for gov module begin") - voteCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.VotesKeyPrefix, func(bz []byte) []byte { - vote := v1beta1.Vote{} - err := cdc.Unmarshal(bz, &vote) - if err != nil { - vote := v1.Vote{} - cdc.MustUnmarshal(bz, &vote) - vote.Voter = utils.ConvertAccAddr(vote.Voter) - voteCount++ - return cdc.MustMarshal(&vote) - } - vote.Voter = utils.ConvertAccAddr(vote.Voter) - voteCount++ - return cdc.MustMarshal(&vote) - }) - depositCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.DepositsKeyPrefix, func(bz []byte) []byte { - deposit := v1beta1.Deposit{} - err := cdc.Unmarshal(bz, &deposit) - if err != nil { - vote := v1.Deposit{} - cdc.MustUnmarshal(bz, &vote) - deposit.Depositor = utils.ConvertAccAddr(deposit.Depositor) - depositCount++ - return cdc.MustMarshal(&deposit) - } - deposit.Depositor = utils.ConvertAccAddr(deposit.Depositor) - depositCount++ - return cdc.MustMarshal(&deposit) - }) -} diff --git a/bech32-migration/slashing/slashing.go b/bech32-migration/slashing/slashing.go deleted file mode 100644 index 1cf01d908..000000000 --- a/bech32-migration/slashing/slashing.go +++ /dev/null @@ -1,27 +0,0 @@ -package slashing - -import ( - storetypes "cosmossdk.io/store/types" - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/slashing/types" - - "github.com/notional-labs/composable/v6/bech32-migration/utils" -) - -func MigrateAddressBech32(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec) { - ctx.Logger().Info("Migration of address bech32 for slashing module begin") - validatorSigningInfoCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.ValidatorSigningInfoKeyPrefix, func(bz []byte) []byte { - validatorSigningInfo := types.ValidatorSigningInfo{} - cdc.MustUnmarshal(bz, &validatorSigningInfo) - validatorSigningInfo.Address = utils.ConvertConsAddr(validatorSigningInfo.Address) - validatorSigningInfoCount++ - return cdc.MustMarshal(&validatorSigningInfo) - }) - - ctx.Logger().Info( - "Migration of address bech32 for slashing module done", - "validator_signing_info_count", validatorSigningInfoCount, - ) -} diff --git a/bech32-migration/staking/staking.go b/bech32-migration/staking/staking.go deleted file mode 100644 index fd82aa692..000000000 --- a/bech32-migration/staking/staking.go +++ /dev/null @@ -1,110 +0,0 @@ -package staking - -import ( - storetypes "cosmossdk.io/store/types" - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/x/staking/types" - - "github.com/notional-labs/composable/v6/bech32-migration/utils" -) - -func MigrateAddressBech32(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec) { - ctx.Logger().Info("Migration of address bech32 for staking module begin") - validatorCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.ValidatorsKey, func(bz []byte) []byte { - validator := types.MustUnmarshalValidator(cdc, bz) - validator.OperatorAddress = utils.ConvertValAddr(validator.OperatorAddress) - validatorCount++ - return types.MustMarshalValidator(cdc, &validator) - }) - delegationCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.DelegationKey, func(bz []byte) []byte { - delegation := types.MustUnmarshalDelegation(cdc, bz) - delegation.DelegatorAddress = utils.ConvertAccAddr(delegation.DelegatorAddress) - delegation.ValidatorAddress = utils.ConvertValAddr(delegation.ValidatorAddress) - delegationCount++ - return types.MustMarshalDelegation(cdc, delegation) - }) - redelegationCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.RedelegationKey, func(bz []byte) []byte { - redelegation := types.MustUnmarshalRED(cdc, bz) - redelegation.DelegatorAddress = utils.ConvertAccAddr(redelegation.DelegatorAddress) - redelegation.ValidatorSrcAddress = utils.ConvertValAddr(redelegation.ValidatorSrcAddress) - redelegation.ValidatorDstAddress = utils.ConvertValAddr(redelegation.ValidatorDstAddress) - redelegationCount++ - return types.MustMarshalRED(cdc, redelegation) - }) - unbondingDelegationCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.UnbondingDelegationKey, func(bz []byte) []byte { - unbonding := types.MustUnmarshalUBD(cdc, bz) - unbonding.DelegatorAddress = utils.ConvertAccAddr(unbonding.DelegatorAddress) - unbonding.ValidatorAddress = utils.ConvertValAddr(unbonding.ValidatorAddress) - unbondingDelegationCount++ - return types.MustMarshalUBD(cdc, unbonding) - }) - historicalInfoCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.HistoricalInfoKey, func(bz []byte) []byte { - historicalInfo := types.MustUnmarshalHistoricalInfo(cdc, bz) - for i := range historicalInfo.Valset { - historicalInfo.Valset[i].OperatorAddress = utils.ConvertValAddr(historicalInfo.Valset[i].OperatorAddress) - } - historicalInfoCount++ - return cdc.MustMarshal(&historicalInfo) - }) - ctx.Logger().Info( - "Migration of address bech32 for staking module done", - "validator_count", validatorCount, - "delegation_count", delegationCount, - "redelegation_count", redelegationCount, - "unbonding_delegation_count", unbondingDelegationCount, - "historical_info_count", historicalInfoCount, - ) -} - -func MigrateUnbonding(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec) { - unbondingQueueKeyCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.UnbondingQueueKey, func(bz []byte) []byte { - pairs := types.DVPairs{} - cdc.MustUnmarshal(bz, &pairs) - for i, pair := range pairs.Pairs { - pairs.Pairs[i].DelegatorAddress = utils.ConvertAccAddr(pair.DelegatorAddress) - pairs.Pairs[i].ValidatorAddress = utils.ConvertValAddr(pair.ValidatorAddress) - } - unbondingQueueKeyCount++ - return cdc.MustMarshal(&pairs) - }) - - redelegationQueueKeyCount := uint64(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.RedelegationQueueKey, func(bz []byte) []byte { - triplets := types.DVVTriplets{} - cdc.MustUnmarshal(bz, &triplets) - - for i, triplet := range triplets.Triplets { - triplets.Triplets[i].DelegatorAddress = utils.ConvertAccAddr(triplet.DelegatorAddress) - triplets.Triplets[i].ValidatorDstAddress = utils.ConvertValAddr(triplet.ValidatorDstAddress) - triplets.Triplets[i].ValidatorSrcAddress = utils.ConvertValAddr(triplet.ValidatorSrcAddress) - } - redelegationQueueKeyCount++ - return cdc.MustMarshal(&triplets) - }) - - validatorQueueKeyCount := uint(0) - utils.IterateStoreByPrefix(ctx, storeKey, types.ValidatorQueueKey, func(bz []byte) []byte { - addrs := types.ValAddresses{} - cdc.MustUnmarshal(bz, &addrs) - - for i, valAddress := range addrs.Addresses { - addrs.Addresses[i] = utils.ConvertValAddr(valAddress) - } - validatorQueueKeyCount++ - return cdc.MustMarshal(&addrs) - }) - - ctx.Logger().Info( - "Migration of address bech32 for staking unboding done", - "unbondingQueueKeyCount", unbondingQueueKeyCount, - "redelegationQueueKeyCount", redelegationQueueKeyCount, - "validatorQueueKeyCount", validatorQueueKeyCount, - ) -} diff --git a/bech32-migration/utils/utils.go b/bech32-migration/utils/utils.go deleted file mode 100644 index 554a3447a..000000000 --- a/bech32-migration/utils/utils.go +++ /dev/null @@ -1,122 +0,0 @@ -package utils - -import ( - "errors" - "strings" - - storetypes "cosmossdk.io/store/types" - sdk "github.com/cosmos/cosmos-sdk/types" -) - -const ( - // OldBech32Prefix defines the Bech32 prefix used for EthAccounts - OldBech32Prefix = "centauri" - - // OldBech32PrefixAccAddr defines the Bech32 prefix of an account's address - OldBech32PrefixAccAddr = OldBech32Prefix - // OldBech32PrefixAccPub defines the Bech32 prefix of an account's public key - OldBech32PrefixAccPub = OldBech32Prefix + sdk.PrefixPublic - // OldBech32PrefixValAddr defines the Bech32 prefix of a validator's operator address - OldBech32PrefixValAddr = OldBech32Prefix + sdk.PrefixValidator + sdk.PrefixOperator - // OldBech32PrefixValPub defines the Bech32 prefix of a validator's operator public key - OldBech32PrefixValPub = OldBech32Prefix + sdk.PrefixValidator + sdk.PrefixOperator + sdk.PrefixPublic - // OldBech32PrefixConsAddr defines the Bech32 prefix of a consensus node address - OldBech32PrefixConsAddr = OldBech32Prefix + sdk.PrefixValidator + sdk.PrefixConsensus - // OldBech32PrefixConsPub defines the Bech32 prefix of a consensus node public key - OldBech32PrefixConsPub = OldBech32Prefix + sdk.PrefixValidator + sdk.PrefixConsensus + sdk.PrefixPublic -) - -func ConvertValAddr(valAddr string) string { - parsedValAddr, err := ValAddressFromOldBech32(valAddr, OldBech32PrefixValAddr) - if err != nil { - return valAddr - } - return parsedValAddr.String() -} - -func ConvertAccAddr(accAddr string) string { - parsedAccAddr, err := AccAddressFromOldBech32(accAddr, OldBech32PrefixAccAddr) - if err != nil { - return accAddr - } - return parsedAccAddr.String() -} - -func ConvertConsAddr(consAddr string) string { - parsedConsAddr, err := ConsAddressFromOldBech32(consAddr, OldBech32PrefixConsAddr) - if err != nil { - return consAddr - } - return parsedConsAddr.String() -} - -func IterateStoreByPrefix( - ctx sdk.Context, storeKey storetypes.StoreKey, prefix []byte, - fn func(value []byte) (newValue []byte), -) { - store := ctx.KVStore(storeKey) - iterator := storetypes.KVStorePrefixIterator(store, prefix) - defer iterator.Close() - - for ; iterator.Valid(); iterator.Next() { - newValue := fn(iterator.Value()) - store.Set(iterator.Key(), newValue) - } -} - -// AccAddressFromBech32 creates an AccAddress from a Bech32 string. -func AccAddressFromOldBech32(address, prefix string) (addr sdk.AccAddress, err error) { - if len(strings.TrimSpace(address)) == 0 { - return sdk.AccAddress{}, errors.New("empty address string is not allowed") - } - - bz, err := sdk.GetFromBech32(address, prefix) - if err != nil { - return nil, err - } - - err = sdk.VerifyAddressFormat(bz) - if err != nil { - return nil, err - } - - return sdk.AccAddress(bz), nil -} - -// ConsAddressFromBech32 creates a ConsAddress from a Bech32 string. -func ConsAddressFromOldBech32(address, prefix string) (addr sdk.ConsAddress, err error) { - if len(strings.TrimSpace(address)) == 0 { - return sdk.ConsAddress{}, errors.New("empty address string is not allowed") - } - - bz, err := sdk.GetFromBech32(address, prefix) - if err != nil { - return nil, err - } - - err = sdk.VerifyAddressFormat(bz) - if err != nil { - return nil, err - } - - return sdk.ConsAddress(bz), nil -} - -// ValAddressFromBech32 creates a ValAddress from a Bech32 string. -func ValAddressFromOldBech32(address, prefix string) (addr sdk.ValAddress, err error) { - if len(strings.TrimSpace(address)) == 0 { - return sdk.ValAddress{}, errors.New("empty address string is not allowed") - } - - bz, err := sdk.GetFromBech32(address, prefix) - if err != nil { - return nil, err - } - - err = sdk.VerifyAddressFormat(bz) - if err != nil { - return nil, err - } - - return sdk.ValAddress(bz), nil -} diff --git a/cmd/centaurid/cmd/bech32_convert.go b/cmd/picad/cmd/bech32_convert.go similarity index 72% rename from cmd/centaurid/cmd/bech32_convert.go rename to cmd/picad/cmd/bech32_convert.go index 336f70fc3..f642caa69 100644 --- a/cmd/centaurid/cmd/bech32_convert.go +++ b/cmd/picad/cmd/bech32_convert.go @@ -12,13 +12,13 @@ var flagBech32Prefix = "prefix" func AddBech32ConvertCommand() *cobra.Command { cmd := &cobra.Command{ Use: "bech32-convert [address]", - Short: "Convert any bech32 string to the centauri prefix", - Long: `Convert any bech32 string to the centauri prefix + Short: "Convert any bech32 string to the pica prefix", + Long: `Convert any bech32 string to the pica prefix Example: - centaurid debug bech32-convert akash1a6zlyvpnksx8wr6wz8wemur2xe8zyh0ytz6d88 + picad debug bech32-convert akash1a6zlyvpnksx8wr6wz8wemur2xe8zyh0ytz6d88 - centaurid debug bech32-convert stride1673f0t8p893rqyqe420mgwwz92ac4qv6synvx2 --prefix osmo + picad debug bech32-convert stride1673f0t8p893rqyqe420mgwwz92ac4qv6synvx2 --prefix osmo `, Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { @@ -43,7 +43,7 @@ Example: }, } - cmd.Flags().StringP(flagBech32Prefix, "p", "composable", "Bech32 Prefix to encode to") + cmd.Flags().StringP(flagBech32Prefix, "p", "picasso", "Bech32 Prefix to encode to") return cmd } diff --git a/cmd/centaurid/cmd/genaccounts.go b/cmd/picad/cmd/genaccounts.go similarity index 94% rename from cmd/centaurid/cmd/genaccounts.go rename to cmd/picad/cmd/genaccounts.go index 7434f2ec9..76ff10b81 100644 --- a/cmd/centaurid/cmd/genaccounts.go +++ b/cmd/picad/cmd/genaccounts.go @@ -8,8 +8,6 @@ import ( "github.com/spf13/cobra" - "github.com/notional-labs/composable/v6/bech32-migration/utils" - "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/crypto/keyring" @@ -201,18 +199,3 @@ contain valid denominations. Accounts may optionally be supplied with vesting pa return cmd } - -func CovertPrefixAddr() *cobra.Command { - cmd := &cobra.Command{ - Use: "convert [address]", - Short: "Convert prefix from layer to centauri", - Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { - newAddr := utils.ConvertAccAddr(args[0]) - fmt.Println(newAddr) - - return nil - }, - } - return cmd -} diff --git a/cmd/centaurid/cmd/root.go b/cmd/picad/cmd/root.go similarity index 99% rename from cmd/centaurid/cmd/root.go rename to cmd/picad/cmd/root.go index 5ae1d7949..b5f138467 100644 --- a/cmd/centaurid/cmd/root.go +++ b/cmd/picad/cmd/root.go @@ -2,10 +2,11 @@ package cmd import ( "errors" - "github.com/cosmos/cosmos-sdk/crypto/keyring" "io" "os" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + "cosmossdk.io/log" "github.com/CosmWasm/wasmd/x/wasm" tmcli "github.com/cometbft/cometbft/libs/cli" @@ -207,7 +208,6 @@ func initRootCmd(rootCmd *cobra.Command, encodingConfig app.EncodingConfig) { tmcli.NewCompletionCmd(rootCmd, true), addDebugCommands(debug.Cmd()), debug.Cmd(), - CovertPrefixAddr(), vestingcli.GetTxCmd(encodingConfig.TxConfig.SigningContext().AddressCodec()), // this line is used by starport scaffolding # stargate/root/commands ) diff --git a/cmd/centaurid/config/config.go b/cmd/picad/config/config.go similarity index 96% rename from cmd/centaurid/config/config.go rename to cmd/picad/config/config.go index ba2184452..c921733df 100644 --- a/cmd/centaurid/config/config.go +++ b/cmd/picad/config/config.go @@ -12,7 +12,7 @@ import ( const ( // Bech32Prefix defines the Bech32 prefix used for EthAccounts - Bech32Prefix = "centauri" + Bech32Prefix = "pica" // Bech32PrefixAccAddr defines the Bech32 prefix of an account's address Bech32PrefixAccAddr = Bech32Prefix @@ -30,7 +30,7 @@ const ( const ( HumanReadableCoinUnit = "PICA" - BaseCoinUnit = "upica" + BaseCoinUnit = "stake" DefaultBondDenom = BaseCoinUnit ) @@ -41,8 +41,8 @@ func SetupConfig() { SetAddressPrefixes(config) config.Seal() - version.AppName = "centauri" - version.Name = "centaurid" + version.AppName = "pica" + version.Name = "picad" } // SetBech32Prefixes sets the global prefixes to be used when serializing addresses and public keys to Bech32 strings. diff --git a/cmd/centaurid/main.go b/cmd/picad/main.go similarity index 70% rename from cmd/centaurid/main.go rename to cmd/picad/main.go index bad5e27a4..5d1d0966a 100644 --- a/cmd/centaurid/main.go +++ b/cmd/picad/main.go @@ -6,8 +6,8 @@ import ( svrcmd "github.com/cosmos/cosmos-sdk/server/cmd" "github.com/notional-labs/composable/v6/app" - cmd "github.com/notional-labs/composable/v6/cmd/centaurid/cmd" - cmdcfg "github.com/notional-labs/composable/v6/cmd/centaurid/config" + cmd "github.com/notional-labs/composable/v6/cmd/picad/cmd" + cmdcfg "github.com/notional-labs/composable/v6/cmd/picad/config" ) func main() { diff --git a/go.sum b/go.sum index 389179ecb..d6e79579f 100644 --- a/go.sum +++ b/go.sum @@ -2551,4 +2551,4 @@ rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= -sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= +sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= \ No newline at end of file diff --git a/kien-todo.md b/kien-todo.md new file mode 100644 index 000000000..056da1199 --- /dev/null +++ b/kien-todo.md @@ -0,0 +1,7 @@ + +#TODO + +Currently, i removed packages that are not used in process of upgrade from sdk47 to 50, to speed up development time + +- bech32-migration pacakges +- upgrade packages prior to v7_0_1 \ No newline at end of file diff --git a/proto/composable/ibctransfermiddleware/v1beta1/tx.proto b/proto/composable/ibctransfermiddleware/v1beta1/tx.proto index a25506804..91cd2c351 100644 --- a/proto/composable/ibctransfermiddleware/v1beta1/tx.proto +++ b/proto/composable/ibctransfermiddleware/v1beta1/tx.proto @@ -6,6 +6,7 @@ import "amino/amino.proto"; import "gogoproto/gogo.proto"; import "cosmos_proto/cosmos.proto"; import "composable/ibctransfermiddleware/v1beta1/ibctransfermiddleware.proto"; +import "cosmos/base/v1beta1/coin.proto"; option go_package = "x/ibctransfermiddleware/types"; @@ -103,14 +104,9 @@ message MsgAddAllowedIbcToken { (gogoproto.customname) = "ChannelID" ]; - string denom = 3 [ - (gogoproto.moretags) = "yaml:\"channel_id\"", - (gogoproto.customname) = "Denom" - ]; - - int64 amount = 4; + cosmos.base.v1beta1.Coin min_fee = 3 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true]; - int64 percentage = 5; + int64 percentage = 4; } message MsgAddAllowedIbcTokenResponse {} diff --git a/scripts/08-wasm/ics10_grandpa_cw.wasm.json b/scripts/08-wasm/ics10_grandpa_cw.wasm.json new file mode 100644 index 000000000..973e23d59 --- /dev/null +++ b/scripts/08-wasm/ics10_grandpa_cw.wasm.json @@ -0,0 +1 @@ +{"deposit":"5000000000000000ppica","messages":[{"@type":"/ibc.lightclients.wasm.v1.MsgPushNewWasmCode","code":"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","signer":"pica10d07y265gmmuvt4z0w9aw880jnsr700jp7sqj5"}],"metadata":"none","summary":"none","title":"none"} \ No newline at end of file diff --git a/scripts/localnode.sh b/scripts/localnode.sh index a6a0edeb9..3acacf83a 100755 --- a/scripts/localnode.sh +++ b/scripts/localnode.sh @@ -29,7 +29,6 @@ rm -rf $HOME_DIR # centaurid config chain-id $CHAINID # if $KEY exists it should be deleted -$BINARY init $MONIKER --chain-id $CHAINID --home $HOME_DIR > /dev/null 2>&1 echo "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" | $BINARY keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --recover --home $HOME_DIR @@ -56,19 +55,3 @@ update_test_genesis '.app_state["staking"]["params"]["bond_denom"]="'$DENOM'"' echo "updating.." sed -i '' 's/timeout_commit = "5s"/timeout_commit = "500ms"/' $HOME_DIR/config/config.toml - -# Collect genesis tx -$BINARY collect-gentxs --home $HOME_DIR - -# Run this to ensure everything worked and that the genesis file is setup correctly -$BINARY validate-genesis --home $HOME_DIR - -if [[ $1 == "pending" ]]; then - echo "pending mode is on, please wait for the first block committed." -fi - -# update request max size so that we can upload the light client -# '' -e is a must have params on mac, if use linux please delete before run -sed -i'' -e 's/max_body_bytes = /max_body_bytes = 1/g' $HOME_DIR/config/config.toml -# Start the node (remove the --pruning=nothing flag if historical queries are not needed) -$BINARY start --pruning=nothing --minimum-gas-prices=0$DENOM --rpc.laddr tcp://0.0.0.0:26657 --home $HOME_DIR --log_level debug diff --git a/scripts/mint_test/setup.sh b/scripts/mint_test/setup.sh index 9733a185f..03789ada4 100644 --- a/scripts/mint_test/setup.sh +++ b/scripts/mint_test/setup.sh @@ -4,15 +4,15 @@ CHANNEL_ID="channel-0" -ESCROW_ADDRESS=$(centaurid q transfermiddleware escrow-address channel-0) +ESCROW_ADDRESS=$(picad q transfermiddleware escrow-address channel-0) hermes --config scripts/relayer_hermes/config_compose_gaia.toml create channel --a-chain centaurid-t1 --b-chain gaiad-t1 --a-port transfer --b-port transfer --new-client-connection --yes gaiad tx ibc-transfer transfer transfer channel-0 "$ESCROW_ADDRESS" 1000000000stake --from gnad --keyring-backend test --chain-id gaiad-t1 --yes --fees 5000stake sleep 20 -balancesEscrowAdress = $(centaurid query bank balances $ESCROW_ADDRESS) +balancesEscrowAdress = $(picad query bank balances $ESCROW_ADDRESS) -centaurid +picad -centaurid tx ibc-transfer transfer transfer channel-0 cosmos1hce8cea32gjg9eaqzxj02jrgc6m6q59wly4zpm +picad tx ibc-transfer transfer transfer channel-0 cosmos1hce8cea32gjg9eaqzxj02jrgc6m6q59wly4zpm diff --git a/scripts/node_start/runnode_banksyd.sh b/scripts/node_start/runnode_banksyd.sh index 2218da305..a778b5294 100755 --- a/scripts/node_start/runnode_banksyd.sh +++ b/scripts/node_start/runnode_banksyd.sh @@ -9,10 +9,10 @@ KEYALGO="secp256k1" KEYRING="test" LOGL="info" -centaurid config keyring-backend $KEYRING -centaurid config chain-id $CHAINID +picad config keyring-backend $KEYRING +picad config chain-id $CHAINID -command -v centaurid > /dev/null 2>&1 || { echo >&2 "centaurid command not found. Ensure this is setup / properly installed in your GOPATH."; exit 1; } +command -v picad > /dev/null 2>&1 || { echo >&2 "centaurid command not found. Ensure this is setup / properly installed in your GOPATH."; exit 1; } command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; } from_scratch () { @@ -23,11 +23,11 @@ from_scratch () { rm -rf ~/.banksy/* # juno1efd63aw40lxf3n4mhf7dzhjkr453axurv2zdzk - echo "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" | centaurid keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --recover + echo "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" | picad keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --recover # juno1hj5fveer5cjtn4wd6wstzugjfdxzl0xps73ftl - echo "wealth flavor believe regret funny network recall kiss grape useless pepper cram hint member few certain unveil rather brick bargain curious require crowd raise" | centaurid keys add myaccount --keyring-backend $KEYRING --algo $KEYALGO --recover + echo "wealth flavor believe regret funny network recall kiss grape useless pepper cram hint member few certain unveil rather brick bargain curious require crowd raise" | picad keys add myaccount --keyring-backend $KEYRING --algo $KEYALGO --recover - centaurid init $MONIKER --chain-id $CHAINID + picad init $MONIKER --chain-id $CHAINID # Function updates the config based on a jq argument as a string update_test_genesis () { @@ -52,16 +52,16 @@ from_scratch () { update_test_genesis '.app_state["feeshare"]["params"]["allowed_denoms"]=["stake"]' # Allocate genesis accounts - centaurid add-genesis-account $KEY 10000000000000000000stake,100000000000000utest --keyring-backend $KEYRING - centaurid add-genesis-account myaccount 1000000000stake,100000000000000utest --keyring-backend $KEYRING + picad add-genesis-account $KEY 10000000000000000000stake,100000000000000utest --keyring-backend $KEYRING + picad add-genesis-account myaccount 1000000000stake,100000000000000utest --keyring-backend $KEYRING - centaurid gentx $KEY 10000000000000000000stake --keyring-backend $KEYRING --chain-id $CHAINID + picad gentx $KEY 10000000000000000000stake --keyring-backend $KEYRING --chain-id $CHAINID # Collect genesis tx - centaurid collect-gentxs + picad collect-gentxs # Run this to ensure junorything worked and that the genesis file is setup correctly - centaurid validate-genesis + picad validate-genesis } @@ -78,9 +78,9 @@ sed -i 's/cors_allowed_origins = \[\]/cors_allowed_origins = \["\*"\]/g' ~/.bank sed -i 's/enable = false/enable = true/g' ~/.banksy/config/app.toml sed -i '/address = "tcp:\/\/0.0.0.0:1317"/c\address = "tcp:\/\/0.0.0.0:1318"' ~/.banksy/config/app.toml -centaurid config node tcp://0.0.0.0:2241 -centaurid start --pruning=nothing --minimum-gas-prices=0stake --p2p.laddr tcp://0.0.0.0:2240 --rpc.laddr tcp://0.0.0.0:2241 --grpc.address 0.0.0.0:2242 --grpc-web.address 0.0.0.0:2243 +picad config node tcp://0.0.0.0:2241 +picad start --pruning=nothing --minimum-gas-prices=0stake --p2p.laddr tcp://0.0.0.0:2240 --rpc.laddr tcp://0.0.0.0:2241 --grpc.address 0.0.0.0:2242 --grpc-web.address 0.0.0.0:2243 #MEMO='{"forward":{"receiver":"cosmos18p5cs3z0q68hq7q0d8tr8kp3ldnqkx2fx3f88w","port":"transfer","channel":"channel-0","timeout":600000000000,"retries":0,"next":"{}"}' -#hermes --config scripts/relayer_hermes/config_compose_gaia.toml create channel --a-chain centaurid-t1 --b-chain gaiad-t1 --a-port transfer --b-port transfer --new-client-connection --yes -#centaurid tx ibc-transfer transfer transfer channel-0 cosmos1alc8mjana7ssgeyffvlfza08gu6rtav8rmj6nv 10000000stake --from myaccount --keyring-backend test --chain-id centaurid-t1 --yes --fees 5000stake \ No newline at end of file +#hermes --config scripts/relayer_hermes/config_compose_gaia.toml create channel --a-chain picad-t1 --b-chain gaiad-t1 --a-port transfer --b-port transfer --new-client-connection --yes +#picad tx ibc-transfer transfer transfer channel-0 cosmos1alc8mjana7ssgeyffvlfza08gu6rtav8rmj6nv 10000000stake --from myaccount --keyring-backend test --chain-id picad-t1 --yes --fees 5000stake \ No newline at end of file diff --git a/scripts/relayer/chains/test-1.json b/scripts/relayer/chains/test-1.json new file mode 100644 index 000000000..c733b0309 --- /dev/null +++ b/scripts/relayer/chains/test-1.json @@ -0,0 +1,21 @@ +{ + "type": "cosmos", + "value": { + "key": "testkey", + "chain-id": "test-1", + "rpc-addr": "http://localhost:16657", + "grpc-addr": "", + "account-prefix": "centauri", + "keyring-backend": "test", + "default-denom": "stake", + "gas-adjustment": 1.5, + "gas-prices": "1stake", + "coin-type": 118, + "debug": true, + "timeout": "10s", + "output-format": "json", + "sign-mode": "direct", + "trusting-period": "330h", + "gas": 900000 + } +} diff --git a/scripts/relayer/chains/test-2.json b/scripts/relayer/chains/test-2.json new file mode 100644 index 000000000..f5d1c5d3e --- /dev/null +++ b/scripts/relayer/chains/test-2.json @@ -0,0 +1,21 @@ +{ + "type": "cosmos", + "value": { + "key": "testkey", + "chain-id": "test-2", + "rpc-addr": "http://localhost:26657", + "grpc-addr": "", + "account-prefix": "centauri", + "keyring-backend": "test", + "default-denom": "stake", + "gas-adjustment": 1.5, + "gas-prices": "100stake", + "coin-type": 118, + "debug": true, + "timeout": "10s", + "output-format": "json", + "sign-mode": "direct", + "trusting-period": "330h", + "gas": 900000 + } +} diff --git a/scripts/relayer/paths/test1-test2.json b/scripts/relayer/paths/test1-test2.json new file mode 100644 index 000000000..144ab176d --- /dev/null +++ b/scripts/relayer/paths/test1-test2.json @@ -0,0 +1,18 @@ +{ + "src": { + "chain-id": "test-1", + "client-id": "", + "connection-id": "", + "channel-id": "" + }, + "dst": { + "chain-id": "test-2", + "client-id": "", + "connection-id": "", + "channel-id": "" + }, + "src-channel-filter": { + "rule": "", + "channel-list": [] + } +} \ No newline at end of file diff --git a/scripts/relayer/relayer-init.sh b/scripts/relayer/relayer-init.sh new file mode 100644 index 000000000..083e9d70c --- /dev/null +++ b/scripts/relayer/relayer-init.sh @@ -0,0 +1,52 @@ +#!/bin/bash + +echo "" +echo "##################" +echo "# Create relayer #" +echo "##################" +echo "" + +# Configure predefined mnemonic pharses +BINARY=rly +CHAIN_DIR=$(pwd)/data +CHAINID_1=test-1 +CHAINID_2=test-2 +RELAYER_DIR=/relayer +MNEMONIC_1="alley afraid soup fall idea toss can goose become valve initial strong forward bright dish figure check leopard decide warfare hub unusual join cart" +MNEMONIC_2="record gift you once hip style during joke field prize dust unique length more pencil transfer quit train device arrive energy sort steak upset" + +echo "Removing previous data..." +rm -rf $CHAIN_DIR/$RELAYER_DIR &> /dev/null + +# Ensure rly is installed +if ! [ -x "$(command -v $BINARY)" ]; then + echo "$BINARY is required to run this script..." + echo "You can download at https://github.com/cosmos/relayer" + exit 1 +fi + +echo "Initializing $BINARY..." +$BINARY config init --home $CHAIN_DIR/$RELAYER_DIR + +echo "Adding configurations for both chains..." +$BINARY chains add-dir ./scripts/relayer/chains --home $CHAIN_DIR/$RELAYER_DIR +$BINARY paths add $CHAINID_1 $CHAINID_2 test1-test2 --file ./scripts/relayer/paths/test1-test2.json --home $CHAIN_DIR/$RELAYER_DIR + +echo "Restoring accounts..." +$BINARY keys restore $CHAINID_1 testkey "$MNEMONIC_1" --home $CHAIN_DIR/$RELAYER_DIR +$BINARY keys restore $CHAINID_2 testkey "$MNEMONIC_2" --home $CHAIN_DIR/$RELAYER_DIR + +echo "Creating clients and a connection..." +$BINARY tx connection test1-test2 --home $CHAIN_DIR/$RELAYER_DIR + +echo "Creating a channel..." +$BINARY tx channel test1-test2 --home $CHAIN_DIR/$RELAYER_DIR + +echo "Starting to listen relayer..." +$BINARY start test1-test2 -p events -b 100 --home $CHAIN_DIR/$RELAYER_DIR > $CHAIN_DIR/relayer.log 2>&1 & + +echo "" +echo "############################" +echo "# SUCCESS: Relayer created #" +echo "############################" +echo "" diff --git a/scripts/run-node.sh b/scripts/run-node.sh new file mode 100755 index 000000000..c544a6398 --- /dev/null +++ b/scripts/run-node.sh @@ -0,0 +1,86 @@ +#!/bin/bash + +BINARY=$1 +CONTINUE=${CONTINUE:-"false"} +HOME_DIR=mytestnet +ENV=${ENV:-""} + +if [ "$CONTINUE" == "true" ]; then + $BINARY start --home $HOME_DIR --log_level debug + exit 0 +fi + +rm -rf mytestnet +pkill centaurid + +# check DENOM is set. If not, set to upica +DENOM=${2:-upica} + +COMMISSION_RATE=0.01 +COMMISSION_MAX_RATE=0.02 + +SED_BINARY=sed +# check if this is OS X +if [[ "$OSTYPE" == "darwin"* ]]; then + # check if gsed is installed + if ! command -v gsed &> /dev/null + then + echo "gsed could not be found. Please install it with 'brew install gnu-sed'" + exit + else + SED_BINARY=gsed + fi +fi + +# check BINARY is set. If not, build picad and set BINARY +if [ -z "$BINARY" ]; then + make build + BINARY=build/picad +fi + +CHAIN_ID="localpica" +KEYRING="test" +KEY="test0" +KEY1="test1" +KEY2="test2" + +# Function updates the config based on a jq argument as a string +update_test_genesis () { + # update_test_genesis '.consensus_params["block"]["max_gas"]="100000000"' + cat $HOME_DIR/config/genesis.json | jq "$1" > $HOME_DIR/config/tmp_genesis.json && mv $HOME_DIR/config/tmp_genesis.json $HOME_DIR/config/genesis.json +} + +$BINARY init --chain-id $CHAIN_ID moniker --home $HOME_DIR + +$BINARY keys add $KEY --keyring-backend $KEYRING --home $HOME_DIR +$BINARY keys add $KEY1 --keyring-backend $KEYRING --home $HOME_DIR +$BINARY keys add $KEY2 --keyring-backend $KEYRING --home $HOME_DIR + +# Allocate genesis accounts (cosmos formatted addresses) +$BINARY add-genesis-account $KEY "1000000000000000000000${DENOM}" --keyring-backend $KEYRING --home $HOME_DIR +$BINARY add-genesis-account $KEY1 "1000000000000000000000${DENOM}" --keyring-backend $KEYRING --home $HOME_DIR +$BINARY add-genesis-account $KEY2 "1000000000000000000000${DENOM}" --keyring-backend $KEYRING --home $HOME_DIR + +update_test_genesis '.app_state["gov"]["params"]["voting_period"]="20s"' +update_test_genesis '.app_state["mint"]["params"]["mint_denom"]="'$DENOM'"' +update_test_genesis '.app_state["gov"]["params"]["min_deposit"]=[{"denom":"'$DENOM'","amount": "1000000"}]' +update_test_genesis '.app_state["crisis"]["constant_fee"]={"denom":"'$DENOM'","amount":"1000"}' +update_test_genesis '.app_state["staking"]["params"]["bond_denom"]="'$DENOM'"' + +# enable rest server and swagger +$SED_BINARY -i '0,/enable = false/s//enable = true/' $HOME_DIR/config/app.toml +$SED_BINARY -i 's/swagger = false/swagger = true/' $HOME_DIR/config/app.toml +$SED_BINARY -i -e 's/enabled-unsafe-cors = false/enabled-unsafe-cors = true/g' $HOME_DIR/config/app.toml +$SED_BINARY -i 's/minimum-gas-prices = "0.25upica"/minimum-gas-prices = "0.0upica"/' $HOME_DIR/config/app.toml + + +# Sign genesis transaction +$BINARY gentx $KEY "1000000000000000000000${DENOM}" --commission-rate=$COMMISSION_RATE --commission-max-rate=$COMMISSION_MAX_RATE --keyring-backend $KEYRING --chain-id $CHAIN_ID --home $HOME_DIR + +# Collect genesis tx +$BINARY collect-gentxs --home $HOME_DIR + +# Run this to ensure everything worked and that the genesis file is setup correctly +$BINARY validate-genesis --home $HOME_DIR +$BINARY start --home $HOME_DIR + diff --git a/scripts/test-upgrade-cosmos-chains.sh b/scripts/test-upgrade-cosmos-chains.sh new file mode 100755 index 000000000..6268fc345 --- /dev/null +++ b/scripts/test-upgrade-cosmos-chains.sh @@ -0,0 +1,157 @@ +#!/bin/bash + +# the upgrade is a fork, "true" otherwise +FORK=${FORK:-"false"} + +OLD_VERSION=v6.4.3 +UPGRADE_WAIT=${UPGRADE_WAIT:-20} +HOME=mytestnet +ROOT=$(pwd) +DENOM=stake +CHAIN_ID1=test-1 +SOFTWARE_UPGRADE_NAME="v6_4_8" +ADDITIONAL_PRE_SCRIPTS="./scripts/upgrade/v_6_4_8/pre-script-ibc-transfer.sh" +ADDITIONAL_AFTER_SCRIPTS="./scripts/upgrade/v_6_4_8/post-script-ibc-transfer.sh" +SETUP_RELAYER_SCRIPTS="./scripts/relayer/relayer-init.sh" + +CHAIN_DIR=$(pwd)/data +CHAINID_1=test-1 + +SLEEP_TIME=1 + +if [[ "$FORK" == "true" ]]; then + export PICA_HALT_HEIGHT=20 +fi + +# underscore so that go tool will not take gocache into account +mkdir -p _build/gocache +export GOMODCACHE=$ROOT/_build/gocache + +# install old binary if not exist +if [ ! -f "_build/$OLD_VERSION.zip" ] &> /dev/null +then + mkdir -p _build/old + wget -c "https://github.com/ComposableFi/composable-cosmos/archive/refs/tags/${OLD_VERSION}.zip" -O _build/${OLD_VERSION}.zip + unzip _build/${OLD_VERSION}.zip -d _build +fi + +# reinstall old binary +if [ $# -eq 1 ] && [ $1 == "--reinstall-old" ] || ! command -v _build/old/centaurid &> /dev/null; then + cd ./_build/composable-cosmos-${OLD_VERSION:1} + GOBIN="$ROOT/_build/old" go install -mod=readonly ./... + cd ../.. +fi + +# install new binary +if ! command -v _build/new/picad &> /dev/null +then + mkdir -p _build/new + GOBIN="$ROOT/_build/new" go install -mod=readonly ./... +fi + +# run old node +echo "running old node" +bash scripts/two-testnodes.sh _build/old/centaurid + +sleep 5 # wait for 2 node to start + +#setup ibc between 2 nodes +echo "setting up ibc" +source $SETUP_RELAYER_SCRIPTS + +# Transfer from chain 1 to chain 2 and return balance of sender on chain 1 +echo "executing additional pre scripts from $ADDITIONAL_PRE_SCRIPTS" +bash ./scripts/upgrade/v_6_4_8/pre-script-ibc-transfer.sh + +run_fork () { + echo "forking" + + while true; do + BLOCK_HEIGHT=$(./_build/old/centaurid status | jq '.SyncInfo.latest_block_height' -r) + # if BLOCK_HEIGHT is not empty + if [ ! -z "$BLOCK_HEIGHT" ]; then + echo "BLOCK_HEIGHT = $BLOCK_HEIGHT" + sleep 10 + else + echo "BLOCK_HEIGHT is empty, forking" + break + fi + done +} + +run_upgrade () { + echo "start upgrading chain-1" + + # Get upgrade height, 12 block after (6s) + STATUS_INFO=($(./_build/old/centaurid status --home $CHAIN_DIR/$CHAINID_1 | jq -r '.NodeInfo.network,.SyncInfo.latest_block_height')) + UPGRADE_HEIGHT=$((STATUS_INFO[1] + 20)) + echo "UPGRADE_HEIGHT = $UPGRADE_HEIGHT" + + tar -cf ./_build/new/picad.tar -C ./_build/new picad + SUM=$(shasum -a 256 ./_build/new/picad.tar | cut -d ' ' -f1) + UPGRADE_INFO=$(jq -n ' + { + "binaries": { + "linux/amd64": "file://'$(pwd)'/_build/new/picad.tar?checksum=sha256:'"$SUM"'", + } + }') + + ./_build/old/centaurid keys list --home $CHAIN_DIR/$CHAINID_1 --keyring-backend test + + ./_build/old/centaurid tx gov submit-legacy-proposal software-upgrade "$SOFTWARE_UPGRADE_NAME" --upgrade-height $UPGRADE_HEIGHT --upgrade-info "$UPGRADE_INFO" --title "upgrade" --description "upgrade" --from val1 --keyring-backend test --chain-id $CHAIN_ID1 --home $CHAIN_DIR/$CHAINID_1 --node tcp://localhost:16657 --output=json -y > /dev/null + + sleep $SLEEP_TIME + + ./_build/old/centaurid tx gov deposit 1 "20000000${DENOM}" --from val1 --keyring-backend test --chain-id $CHAIN_ID1 --home $CHAIN_DIR/$CHAINID_1 --node tcp://localhost:16657 --output=json -y > /dev/null + + sleep $SLEEP_TIME + + ./_build/old/centaurid tx gov vote 1 yes --from val1 --keyring-backend test --chain-id $CHAIN_ID1 --home $CHAIN_DIR/$CHAINID_1 --node tcp://localhost:16657 --output=json -y > /dev/null + + sleep $SLEEP_TIME + + # determine block_height to halt + while true; do + BLOCK_HEIGHT=$(./_build/old/centaurid status --home $CHAIN_DIR/$CHAINID_1 | jq '.SyncInfo.latest_block_height' -r) + if [ $BLOCK_HEIGHT = "$UPGRADE_HEIGHT" ]; then + # only kill the first centaurid + echo "BLOCK HEIGHT = $UPGRADE_HEIGHT REACHED, KILLING OLD ONE" + pkill -o centaurid + break + else + ./_build/old/centaurid q gov proposal 1 --home $CHAIN_DIR/$CHAINID_1 --output=json | jq ".status" + echo "BLOCK_HEIGHT = $BLOCK_HEIGHT" + sleep 1 + fi + done +} + +# if FORK = true +if [[ "$FORK" == "true" ]]; then + run_fork + unset PICA_HALT_HEIGHT +else + run_upgrade +fi + +sleep 1 + +echo "" +echo "#########################################################" +echo "# UPGRADE CHAIN 1 SUCCESSFUL #" +echo "#########################################################" +echo "" + +# run new node +CONTINUE="true" bash scripts/two-testnodes.sh _build/new/picad + +sleep 5 + +echo "executing additional post scripts from $ADDITIONAL_AFTER_SCRIPTS" +bash ./scripts/upgrade/v_6_4_8/post-script-ibc-transfer.sh + +echo "" +echo "#########################################################" +echo "# INTERCHAIN TEST SUCCESSFUL #" +echo "#########################################################" +echo "" \ No newline at end of file diff --git a/scripts/test-upgrade.sh b/scripts/test-upgrade.sh index 9e8ac64cc..eb2cd61b6 100755 --- a/scripts/test-upgrade.sh +++ b/scripts/test-upgrade.sh @@ -39,7 +39,7 @@ if [ $# -eq 1 ] && [ $1 == "--reinstall-old" ] || ! command -v _build/old/centau fi # install new binary -if ! command -v _build/new/centaurid &> /dev/null +if ! command -v _build/new/picad &> /dev/null then mkdir -p _build/new GOBIN="$ROOT/_build/new" go install -mod=readonly ./... @@ -93,15 +93,15 @@ run_upgrade () { # Get upgrade height, 12 block after (6s) STATUS_INFO=($(./_build/old/centaurid status --home $HOME | jq -r '.NodeInfo.network,.SyncInfo.latest_block_height')) - UPGRADE_HEIGHT=$((STATUS_INFO[1] + 50)) + UPGRADE_HEIGHT=$((STATUS_INFO[1] + 20)) echo "UPGRADE_HEIGHT = $UPGRADE_HEIGHT" - tar -cf ./_build/new/centaurid.tar -C ./_build/new centaurid - SUM=$(shasum -a 256 ./_build/new/centaurid.tar | cut -d ' ' -f1) + tar -cf ./_build/new/picad.tar -C ./_build/new picad + SUM=$(shasum -a 256 ./_build/new/picad.tar | cut -d ' ' -f1) UPGRADE_INFO=$(jq -n ' { "binaries": { - "linux/amd64": "file://'$(pwd)'/_build/new/centaurid.tar?checksum=sha256:'"$SUM"'", + "linux/amd64": "file://'$(pwd)'/_build/new/picad.tar?checksum=sha256:'"$SUM"'", } }') @@ -151,9 +151,9 @@ sleep 1 # run new node echo -e "\n\n=> =>continue running nodes after upgrade" if [[ "$OSTYPE" == "darwin"* ]]; then - CONTINUE="true" bash scripts/localnode.sh _build/new/centaurid $DENOM + CONTINUE="true" screen -L -dmS picad bash scripts/localnode.sh _build/new/picad $DENOM else - CONTINUE="true" bash scripts/localnode.sh _build/new/centaurid $DENOM + CONTINUE="true" screen -L -dmS picad bash scripts/localnode.sh _build/new/picad $DENOM fi sleep 5 @@ -167,7 +167,7 @@ if [ ! -z "$ADDITIONAL_AFTER_SCRIPTS" ]; then # check if SCRIPT is a file if [ -f "$SCRIPT" ]; then echo "executing additional after scripts from $SCRIPT" - source $SCRIPT _build/new/centaurid + source $SCRIPT _build/new/picad sleep 5 else echo "$SCRIPT is not a file" diff --git a/scripts/testnode.sh b/scripts/testnode.sh index 41eb8b0ee..44fc57341 100755 --- a/scripts/testnode.sh +++ b/scripts/testnode.sh @@ -60,4 +60,8 @@ fi sed -i'' -e 's/max_body_bytes = /max_body_bytes = 1/g' ~/.banksy/config/config.toml # Start the node (remove the --pruning=nothing flag if historical queries are not needed) +<<<<<<< HEAD $BINARY start --pruning=nothing --minimum-gas-prices=0.0001ppica --rpc.laddr tcp://0.0.0.0:26657 +======= +# centaurid start --pruning=nothing --minimum-gas-prices=0.0001ppica --rpc.laddr tcp://0.0.0.0:26657 +>>>>>>> develop2 diff --git a/scripts/two-testnodes.sh b/scripts/two-testnodes.sh new file mode 100755 index 000000000..dc195c32d --- /dev/null +++ b/scripts/two-testnodes.sh @@ -0,0 +1,179 @@ +#!/bin/bash + +BINARY=$1 +CONTINUE=${CONTINUE:-"false"} +CHAIN_DIR=$(pwd)/data +CHAINID_1=test-1 +CHAINID_2=test-2 +KEYRING="test" + +### Custom genesis files +DENOM=stake +GENESIS_1=$CHAIN_DIR/$CHAINID_1/config/genesis.json +TMP_GENESIS_1=$CHAIN_DIR/$CHAINID_1/config/genesis.json.tmp + +GENESIS_2=$CHAIN_DIR/$CHAINID_2/config/genesis.json +TMP_GENESIS_2=$CHAIN_DIR/$CHAINID_2/config/genesis.json.tmp + +VAL_MNEMONIC_1="clock post desk civil pottery foster expand merit dash seminar song memory figure uniform spice circle try happy obvious trash crime hybrid hood cushion" +VAL_MNEMONIC_2="angry twist harsh drastic left brass behave host shove marriage fall update business leg direct reward object ugly security warm tuna model broccoli choice" +WALLET_MNEMONIC_1="banner spread envelope side kite person disagree path silver will brother under couch edit food venture squirrel civil budget number acquire point work mass" +WALLET_MNEMONIC_2="veteran try aware erosion drink dance decade comic dawn museum release episode original list ability owner size tuition surface ceiling depth seminar capable only" +WALLET_MNEMONIC_3="vacuum burst ordinary enact leaf rabbit gather lend left chase park action dish danger green jeans lucky dish mesh language collect acquire waste load" +WALLET_MNEMONIC_4="open attitude harsh casino rent attitude midnight debris describe spare cancel crisp olive ride elite gallery leaf buffalo sheriff filter rotate path begin soldier" +RLY_MNEMONIC_1="alley afraid soup fall idea toss can goose become valve initial strong forward bright dish figure check leopard decide warfare hub unusual join cart" +RLY_MNEMONIC_2="record gift you once hip style during joke field prize dust unique length more pencil transfer quit train device arrive energy sort steak upset" + +P2PPORT_1=16656 +P2PPORT_2=26656 +RPCPORT_1=16657 +RPCPORT_2=26657 +RESTPORT_1=1316 +RESTPORT_2=1317 +ROSETTA_1=8080 +ROSETTA_2=8081 +GRPCPORT_1=8090 +GRPCPORT_2=9090 +GRPCWEB_1=8091 +GRPCWEB_2=9091 + +if [ "$CONTINUE" == "true" ]; then + picad start --log_level trace --log_format json --home $CHAIN_DIR/$CHAINID_1 --pruning=nothing --grpc.address="0.0.0.0:$GRPCPORT_1" --grpc-web.address="0.0.0.0:$GRPCWEB_1" > $CHAIN_DIR/$CHAINID_1.log 2>&1 & + exit 0 +fi + +#Kill any used ports +PORTS=(16656 26656 16657 26657 1316 1317 8080 8081 8090 9090 8091 9091) +# Iterate over each port number +for PORT_NUMBER in "${PORTS[@]}"; do + # Check if any process is running on the specified port + PROCESS_ID=$(lsof -ti :$PORT_NUMBER) + + # If a process is found, kill it + if [ -n "$PROCESS_ID" ]; then + echo "Process found on port $PORT_NUMBER with PID: $PROCESS_ID. Killing..." + kill $PROCESS_ID + echo "Process killed." + else + echo "No process found on port $PORT_NUMBER." + fi +done + +# Stop if it is already running +if pgrep -x "$BINARY" >/dev/null; then + echo "Terminating $BINARY..." + killall $BINARY +fi + +echo "Removing previous data..." +rm -rf $CHAIN_DIR/$CHAINID_1 &> /dev/null +rm -rf $CHAIN_DIR/$CHAINID_2 &> /dev/null + +# Add directories for both chains, exit if an error occurs +if ! mkdir -p $CHAIN_DIR/$CHAINID_1 2>/dev/null; then + echo "Failed to create chain folder. Aborting..." + exit 1 +fi + +if ! mkdir -p $CHAIN_DIR/$CHAINID_2 2>/dev/null; then + echo "Failed to create chain folder. Aborting..." + exit 1 +fi + +echo "Initializing $CHAINID_1 & $CHAINID_2..." +$BINARY init test --home $CHAIN_DIR/$CHAINID_1 --chain-id=$CHAINID_1 &> /dev/null +$BINARY init test --home $CHAIN_DIR/$CHAINID_2 --chain-id=$CHAINID_2 &> /dev/null + +$BINARY config keyring-backend $KEYRING + +echo "Adding genesis accounts..." +echo $VAL_MNEMONIC_1 | $BINARY keys add val1 --home $CHAIN_DIR/$CHAINID_1 --recover --keyring-backend=test +echo $VAL_MNEMONIC_2 | $BINARY keys add val2 --home $CHAIN_DIR/$CHAINID_2 --recover --keyring-backend=test +echo $WALLET_MNEMONIC_1 | $BINARY keys add wallet1 --home $CHAIN_DIR/$CHAINID_1 --recover --keyring-backend=test +echo $WALLET_MNEMONIC_2 | $BINARY keys add wallet2 --home $CHAIN_DIR/$CHAINID_2 --recover --keyring-backend=test +echo $WALLET_MNEMONIC_3 | $BINARY keys add wallet3 --home $CHAIN_DIR/$CHAINID_1 --recover --keyring-backend=test +echo $WALLET_MNEMONIC_4 | $BINARY keys add wallet4 --home $CHAIN_DIR/$CHAINID_2 --recover --keyring-backend=test +echo $RLY_MNEMONIC_1 | $BINARY keys add rly1 --home $CHAIN_DIR/$CHAINID_1 --recover --keyring-backend=test +echo $RLY_MNEMONIC_2 | $BINARY keys add rly2 --home $CHAIN_DIR/$CHAINID_2 --recover --keyring-backend=test + +VAL1_ADDR=$($BINARY keys show val1 --home $CHAIN_DIR/$CHAINID_1 --keyring-backend test -a) +VAL2_ADDR=$($BINARY keys show val2 --home $CHAIN_DIR/$CHAINID_2 --keyring-backend test -a) +WALLET1_ADDR=$($BINARY keys show wallet1 --home $CHAIN_DIR/$CHAINID_1 --keyring-backend test -a) +WALLET2_ADDR=$($BINARY keys show wallet2 --home $CHAIN_DIR/$CHAINID_2 --keyring-backend test -a) +WALLET3_ADDR=$($BINARY keys show wallet3 --home $CHAIN_DIR/$CHAINID_1 --keyring-backend test -a) +WALLET4_ADDR=$($BINARY keys show wallet4 --home $CHAIN_DIR/$CHAINID_2 --keyring-backend test -a) +RLY1_ADDR=$($BINARY keys show rly1 --home $CHAIN_DIR/$CHAINID_1 --keyring-backend test -a) +RLY2_ADDR=$($BINARY keys show rly2 --home $CHAIN_DIR/$CHAINID_2 --keyring-backend test -a) + +$BINARY add-genesis-account $VAL1_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_1 +$BINARY add-genesis-account $VAL2_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_2 +$BINARY add-genesis-account $WALLET1_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_1 +$BINARY add-genesis-account $WALLET2_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_2 +$BINARY add-genesis-account $RLY1_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_1 +$BINARY add-genesis-account $RLY2_ADDR "100000000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_2 + +echo "Creating and collecting gentx..." +$BINARY gentx val1 "1000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_1 --chain-id $CHAINID_1 --keyring-backend test +$BINARY gentx val2 "1000000000000000000000${DENOM}" --home $CHAIN_DIR/$CHAINID_2 --chain-id $CHAINID_2 --keyring-backend test +$BINARY collect-gentxs --home $CHAIN_DIR/$CHAINID_1 &> /dev/null +$BINARY collect-gentxs --home $CHAIN_DIR/$CHAINID_2 &> /dev/null + +echo "Changing defaults and ports in app.toml and config.toml files..." +sed -i -e 's#"tcp://0.0.0.0:26656"#"tcp://localhost:'"$P2PPORT_1"'"#g' $CHAIN_DIR/$CHAINID_1/config/config.toml +sed -i -e 's#"tcp://127.0.0.1:26657"#"tcp://localhost:'"$RPCPORT_1"'"#g' $CHAIN_DIR/$CHAINID_1/config/config.toml +sed -i -e 's#"tcp://localhost:26657"#"tcp://localhost:'"$RPCPORT_1"'"#g' $CHAIN_DIR/$CHAINID_1/config/client.toml +sed -i -e 's/timeout_commit = "5s"/timeout_commit = "1s"/g' $CHAIN_DIR/$CHAINID_1/config/config.toml +sed -i -e 's/timeout_propose = "3s"/timeout_propose = "1s"/g' $CHAIN_DIR/$CHAINID_1/config/config.toml +sed -i -e 's/index_all_keys = false/index_all_keys = true/g' $CHAIN_DIR/$CHAINID_1/config/config.toml +sed -i -e 's/enable = false/enable = true/g' $CHAIN_DIR/$CHAINID_1/config/app.toml +sed -i -e 's/swagger = false/swagger = true/g' $CHAIN_DIR/$CHAINID_1/config/app.toml +sed -i -e 's#"tcp://localhost:1317"#"tcp://localhost:'"$RESTPORT_1"'"#g' $CHAIN_DIR/$CHAINID_1/config/app.toml +sed -i -e 's#":8080"#":'"$ROSETTA_1"'"#g' $CHAIN_DIR/$CHAINID_1/config/app.toml +sed -i -e 's/enabled-unsafe-cors = false/enabled-unsafe-cors = true/g' $CHAIN_DIR/$CHAINID_1/config/app.toml + + +sed -i -e 's#"tcp://0.0.0.0:26656"#"tcp://localhost:'"$P2PPORT_2"'"#g' $CHAIN_DIR/$CHAINID_2/config/config.toml +sed -i -e 's#"tcp://127.0.0.1:26657"#"tcp://localhost:'"$RPCPORT_2"'"#g' $CHAIN_DIR/$CHAINID_2/config/config.toml +sed -i -e 's#"tcp://localhost:26657"#"tcp://localhost:'"$RPCPORT_2"'"#g' $CHAIN_DIR/$CHAINID_2/config/client.toml +sed -i -e 's/timeout_commit = "5s"/timeout_commit = "1s"/g' $CHAIN_DIR/$CHAINID_2/config/config.toml +sed -i -e 's/timeout_propose = "3s"/timeout_propose = "1s"/g' $CHAIN_DIR/$CHAINID_2/config/config.toml +sed -i -e 's/index_all_keys = false/index_all_keys = true/g' $CHAIN_DIR/$CHAINID_2/config/config.toml +sed -i -e 's/enable = false/enable = true/g' $CHAIN_DIR/$CHAINID_2/config/app.toml +sed -i -e 's/swagger = false/swagger = true/g' $CHAIN_DIR/$CHAINID_2/config/app.toml +sed -i -e 's#"tcp://localhost:1317"#"tcp://localhost:'"$RESTPORT_2"'"#g' $CHAIN_DIR/$CHAINID_2/config/app.toml +sed -i -e 's#":8080"#":'"$ROSETTA_2"'"#g' $CHAIN_DIR/$CHAINID_2/config/app.toml +sed -i -e 's/enabled-unsafe-cors = false/enabled-unsafe-cors = true/g' $CHAIN_DIR/$CHAINID_2/config/app.toml + + +echo "Changing genesis.json..." +sed -i -e 's/"voting_period": "172800s"/"voting_period": "10s"/g' $CHAIN_DIR/$CHAINID_1/config/genesis.json +sed -i -e 's/"voting_period": "172800s"/"voting_period": "10s"/g' $CHAIN_DIR/$CHAINID_2/config/genesis.json +sed -i -e 's/"reward_delay_time": "604800s"/"reward_delay_time": "0s"/g' $CHAIN_DIR/$CHAINID_1/config/genesis.json +sed -i -e 's/"reward_delay_time": "604800s"/"reward_delay_time": "0s"/g' $CHAIN_DIR/$CHAINID_2/config/genesis.json + + +# Update the genesis file +update_test_genesis () { + jq "$1" $GENESIS_1 > $TMP_GENESIS_1 && mv $TMP_GENESIS_1 $GENESIS_1 + jq "$1" $GENESIS_2 > $TMP_GENESIS_2 && mv $TMP_GENESIS_2 $GENESIS_2 +} + +# echo "update test genesis" +# update_test_genesis ".app_state[\"staking\"][\"params\"][\"bond_denom\"]=\"$DENOM\"" +# update_test_genesis ".app_state[\"mint\"][\"params\"][\"mint_denom\"]=\"$DENOM\"" +# update_test_genesis ".app_state[\"crisis\"][\"constant_fee\"][\"denom\"]=\"$DENOM\"" +# update_test_genesis ".app_state[\"gov\"][\"params\"][\"min_deposit\"][0][\"denom\"]=\"$DENOM\"" +# update_test_genesis ".app_state[\"tokenfactory\"][\"params\"][\"denom_creation_fee\"][0][\"denom\"]=\"$DENOM\"" +# update_test_genesis ".app_state[\"feeburn\"][\"params\"][\"tx_fee_burn_percent\"]=\"50\"" + + +# Starting the chain +echo "Starting $CHAINID_1 in $CHAIN_DIR..." +echo "Creating log file at $CHAIN_DIR/$CHAINID_1.log" +$BINARY start --log_level trace --log_format json --home $CHAIN_DIR/$CHAINID_1 --pruning=nothing --grpc.address="0.0.0.0:$GRPCPORT_1" --grpc-web.address="0.0.0.0:$GRPCWEB_1" > $CHAIN_DIR/$CHAINID_1.log 2>&1 & + +sleep 5 + +echo "Starting $CHAINID_2 in $CHAIN_DIR..." +echo "Creating log file at $CHAIN_DIR/$CHAINID_2.log" +$BINARY start --log_level trace --log_format json --home $CHAIN_DIR/$CHAINID_2 --pruning=nothing --grpc.address="0.0.0.0:$GRPCPORT_2" --grpc-web.address="0.0.0.0:$GRPCWEB_2" > $CHAIN_DIR/$CHAINID_2.log 2>&1 & diff --git a/scripts/upgrade/contracts/counter.wasm b/scripts/upgrade/contracts/counter.wasm new file mode 100644 index 000000000..e3e5b53bd Binary files /dev/null and b/scripts/upgrade/contracts/counter.wasm differ diff --git a/scripts/upgrade/init-deps.sh b/scripts/upgrade/init-deps.sh new file mode 100644 index 000000000..c61aaf6c0 --- /dev/null +++ b/scripts/upgrade/init-deps.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +OLD_VERSION=kien-picad-6.6 +SOFTWARE_UPGRADE_NAME="v7_0_1" +ROOT=$(pwd) + +COMPOSABLE_VERSION="branchfortestingpfmfix" + +mkdir -p _build/ + + +# Check if the directory exists and is a Git repository +# TODO: using git, since nix in composable repo requires something with git +# Consider using submodule, or firgure this out +if [ ! -d "_build/composable/.git" ]; then + cd _build/ + git clone https://github.com/ComposableFi/composable.git composable + cd composable + git checkout "$COMPOSABLE_VERSION" + cd ../.././ +fi + + +# install old binary if not exist +if [ ! -f "_build/$OLD_VERSION.zip" ] &> /dev/null +then + mkdir -p _build/old + wget -c "https://github.com/notional-labs/composable-cosmos/archive/refs/tags/${OLD_VERSION}.zip" -O _build/${OLD_VERSION}.zip + unzip _build/${OLD_VERSION}.zip -d _build +fi + +# reinstall old binary +if [ $# -eq 1 ] && [ $1 == "--reinstall-old" ] || ! command -v _build/old/centaurid &> /dev/null; then + cd ./_build/composable-cosmos-${OLD_VERSION} + GOBIN="$ROOT/_build/old" go install -mod=readonly ./... + cd ../.. +fi + + +# install new binary +if ! command -v _build/new/picad &> /dev/null +then + echo -e "\n =>installing new picad... \n \n" + mkdir -p _build/new + GOBIN="$ROOT/_build/new" make install +fi + diff --git a/scripts/upgrade/init_deps.sh b/scripts/upgrade/init_deps.sh new file mode 100755 index 000000000..1ff71edf2 --- /dev/null +++ b/scripts/upgrade/init_deps.sh @@ -0,0 +1,47 @@ +#!/bin/bash + + +OLD_VERSION=kien-develop2 +SOFTWARE_UPGRADE_NAME="v7_0_1" +ROOT=$(pwd) + +COMPOSABLE_VERSION="branchfortestingpfmfix" + +mkdir -p _build/ + + +# Check if the directory exists and is a Git repository +# TODO: using git, since nix in composable repo requires something with git +# Consider using submodule, or firgure this out +if [ ! -d "_build/composable/.git" ]; then + cd _build/ + git clone https://github.com/ComposableFi/composable.git composable + cd composable + git checkout "$COMPOSABLE_VERSION" + cd ../.././ +fi + + +# install old binary if not exist +if [ ! -f "_build/$OLD_VERSION.zip" ] &> /dev/null +then + mkdir -p _build/old + wget -c "https://github.com/notional-labs/composable-cosmos/archive/refs/tags/${OLD_VERSION}.zip" -O _build/${OLD_VERSION}.zip + unzip _build/${OLD_VERSION}.zip -d _build +fi + +# reinstall old binary +if [ $# -eq 1 ] && [ $1 == "--reinstall-old" ] || ! command -v _build/old/centaurid &> /dev/null; then + cd ./_build/composable-cosmos-${OLD_VERSION} + GOBIN="$ROOT/_build/old" go install -mod=readonly ./... + cd ../.. +fi + + +# install new binary +if ! command -v _build/new/picad &> /dev/null +then + mkdir -p _build/new + GOBIN="$ROOT/_build/new" make install +fi + diff --git a/scripts/upgrade/localnode.sh b/scripts/upgrade/localnode.sh new file mode 100755 index 000000000..6e313b356 --- /dev/null +++ b/scripts/upgrade/localnode.sh @@ -0,0 +1,76 @@ +#!/bin/bash + +KEY="mykey" +KEY1="mykey1" +CHAINID="centauri-dev" +MONIKER="localtestnet" +KEYALGO="secp256k1" +KEYRING="test" +LOGLEVEL="info" +BINARY=$1 +# to trace evm +#TRACE="--trace" +TRACE="" + +HOME_DIR=mytestnet +DENOM=ppica + +# remove existing daemon +rm -rf $HOME_DIR + +if [ ! -x "$(command -v $BINARY)" ]; then + echo "Error: Binary $BINARY is not executable or not found." + exit 1 +fi + + +if [ "$CONTINUE" == "true" ]; then + echo "\n ->> continuing from previous state" + $BINARY start --home $HOME_DIR --log_level debug + exit 0 +fi + + +$BINARY config keyring-backend $KEYRING +$BINARY config chain-id $CHAINID + + +# if $KEY exists it should be deleted +echo "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" | $BINARY keys add $KEY --keyring-backend $KEYRING --algo $KEYALGO --recover --home $HOME_DIR +echo "bottom loan skill merry east cradle onion journey palm apology verb edit desert impose absurd oil bubble sweet glove shallow size build burst effort" | $BINARY keys add $KEY1 --keyring-backend $KEYRING --algo $KEYALGO --recover --home $HOME_DIR +$BINARY init $CHAINID --chain-id $CHAINID --default-denom "ppica" --home $HOME_DIR + +update_test_genesis () { + # update_test_genesis '.consensus_params["block"]["max_gas"]="100000000"' + cat $HOME_DIR/config/genesis.json | jq "$1" > $HOME_DIR/config/tmp_genesis.json && cp $HOME_DIR/config/tmp_genesis.json $HOME_DIR/config/genesis.json +} + +# Allocate genesis accounts (cosmos formatted addresses) +$BINARY add-genesis-account $KEY 100000000000000000000000000ppica --keyring-backend $KEYRING --home $HOME_DIR +$BINARY add-genesis-account $KEY1 100000000000000000000000000ppica --keyring-backend $KEYRING --home $HOME_DIR + +# Sign genesis transaction +$BINARY gentx $KEY 10030009994127689ppica --keyring-backend $KEYRING --chain-id $CHAINID --home $HOME_DIR + +update_test_genesis '.app_state["gov"]["params"]["voting_period"]="20s"' +update_test_genesis '.app_state["mint"]["params"]["mint_denom"]="'$DENOM'"' +update_test_genesis '.app_state["gov"]["params"]["min_deposit"]=[{"denom":"'$DENOM'","amount": "1"}]' +update_test_genesis '.app_state["crisis"]["constant_fee"]={"denom":"'$DENOM'","amount":"1000"}' + +# Collect genesis tx +$BINARY collect-gentxs --home $HOME_DIR + +# Run this to ensure everything worked and that the genesis file is setup correctly +$BINARY validate-genesis --home $HOME_DIR + +if [[ $1 == "pending" ]]; then + echo "pending mode is on, please wait for the first block committed." +fi + +# update request max size so that we can upload the light client +# '' -e is a must have params on mac, if use linux please delete before run +sed -i'' -e 's/max_body_bytes = /max_body_bytes = 1/g' $HOME_DIR/config/config.toml +sed -i'' -e 's/max_tx_bytes = 1048576/max_tx_bytes = 10000000/g' $HOME_DIR/config/config.toml + + +$BINARY start --rpc.unsafe --rpc.laddr tcp://0.0.0.0:26657 --pruning=nothing --minimum-gas-prices=0.001ppica --home=$HOME_DIR --log_level trace --trace --with-tendermint=true --transport=socket --grpc.enable=true --grpc-web.enable=false --api.enable=true --p2p.pex=false --p2p.upnp=false \ No newline at end of file diff --git a/scripts/upgrade/old-node-scripts.sh b/scripts/upgrade/old-node-scripts.sh new file mode 100755 index 000000000..732ddd7b9 --- /dev/null +++ b/scripts/upgrade/old-node-scripts.sh @@ -0,0 +1,13 @@ +ADDITIONAL_SCRIPTS=( + "./scripts/upgrade/v_6_6_0/setup-08-wasm.sh" +) + +for SCRIPT in "${ADDITIONAL_SCRIPTS[@]}"; do + if [ -f "$SCRIPT" ]; then + echo "Running additional script: $SCRIPT" + source $SCRIPT + else + echo "Additional script $SCRIPT does not exist." + fi +done + diff --git a/scripts/upgrade/setup-old-picad-node.sh b/scripts/upgrade/setup-old-picad-node.sh new file mode 100755 index 000000000..60238677b --- /dev/null +++ b/scripts/upgrade/setup-old-picad-node.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +# the upgrade is a fork, "true" otherwise +FORK=${FORK:-"false"} + + +BINARY=_build/old/picad +HOME=mytestnet +ROOT=$(pwd) +DENOM=ppica +CHAIN_ID=centaurid + +ADDITIONAL_PRE_SCRIPTS="./scripts/upgrade/old-node-scripts.sh" + +SLEEP_TIME=1 + + +screen -L -dmS node1 bash scripts/upgrade/localnode.sh $BINARY $DENOM --Logfile $HOME/log-screen.txt + +#screen -L -dmS bash scripts/upgrade/localnode.sh $BINARY $DENOM --Logfile $HOME/log-screen.txt +#scripts/localnode.sh $BINARY + +sleep 10 # wait for note to start + +# execute additional pre scripts +source $ADDITIONAL_PRE_SCRIPTS + diff --git a/scripts/upgrade/setup-polkadot-node.sh b/scripts/upgrade/setup-polkadot-node.sh new file mode 100755 index 000000000..dadd487ff --- /dev/null +++ b/scripts/upgrade/setup-polkadot-node.sh @@ -0,0 +1,6 @@ +ROOT=$(pwd) + +cd $ROOT/_build/composable + +# This start the node +nix run .#zombienet-rococo-local-picasso-dev diff --git a/scripts/upgrade/setup-relayer.sh b/scripts/upgrade/setup-relayer.sh new file mode 100644 index 000000000..ca8f83501 --- /dev/null +++ b/scripts/upgrade/setup-relayer.sh @@ -0,0 +1,20 @@ + +ROOT=$(pwd) + +cd $ROOT/_build/composable/ + +# init clients +nix run .#picasso-centauri-ibc-init +sleep 1 + +# init connection +nix run .#picasso-centauri-ibc-connection-init +sleep 1 + +# init channel +nix run .#picasso-centauri-ibc-channels-init +sleep 1 + + # run relayer +nix run .#picasso-centauri-ibc-relay +sleep 1 \ No newline at end of file diff --git a/scripts/upgrade/upgrade.sh b/scripts/upgrade/upgrade.sh new file mode 100755 index 000000000..000babe67 --- /dev/null +++ b/scripts/upgrade/upgrade.sh @@ -0,0 +1,80 @@ +# the upgrade is a fork, "true" otherwise +FORK=${FORK:-"false"} + +UPGRADE_WAIT=${UPGRADE_WAIT:-20} +HOME=mytestnet +ROOT=$(pwd) +DENOM=ppica +CHAIN_ID=centauri-dev +SOFTWARE_UPGRADE_NAME="v7_0_1" +ADDITIONAL_PRE_SCRIPTS="./scripts/upgrade/v_6_4_8/pre-script.sh" +ADDITIONAL_AFTER_SCRIPTS="./scripts/upgrade/v_6_4_8/post-script.sh" +KEY="mykey" +KEY1="mykey1" + +SLEEP_TIME=5 + + +UPGRADE_PROPOSAL_ID=2 +run_upgrade () { + echo -e "\n\n=> =>start upgrading" + + # Get upgrade height, 12 block after (6s) + STATUS_INFO=($(./_build/old/picad status --home $HOME | jq -r '.NodeInfo.network,.SyncInfo.latest_block_height')) + UPGRADE_HEIGHT=$((STATUS_INFO[1] + 8)) + echo "UPGRADE_HEIGHT = $UPGRADE_HEIGHT" + + tar -cf ./_build/new/picad.tar -C ./_build/new picad + SUM=$(shasum -a 256 ./_build/new/picad.tar | cut -d ' ' -f1) + UPGRADE_INFO=$(jq -n ' + { + "binaries": { + "linux/amd64": "file://'$(pwd)'/_build/new/picad.tar?checksum=sha256:'"$SUM"'", + } + }') + + + ./_build/old/picad tx gov submit-legacy-proposal software-upgrade "$SOFTWARE_UPGRADE_NAME" --upgrade-height $UPGRADE_HEIGHT --upgrade-info "$UPGRADE_INFO" --title "upgrade" --description "upgrade" --from $KEY --fees 100000${DENOM} --keyring-backend test --chain-id $CHAIN_ID --home $HOME -y > /dev/null + + sleep $SLEEP_TIME + + ./_build/old/picad tx gov deposit $UPGRADE_PROPOSAL_ID "20000000${DENOM}" --from $KEY --keyring-backend test --fees 100000${DENOM} --chain-id $CHAIN_ID --home $HOME -y + + sleep $SLEEP_TIME + + ./_build/old/picad tx gov vote $UPGRADE_PROPOSAL_ID yes --from $KEY --keyring-backend test --fees 100000${DENOM} --chain-id $CHAIN_ID --home $HOME -y + + sleep $SLEEP_TIME + + + # determine block_height to halt + while true; do + BLOCK_HEIGHT=$(./_build/old/picad status | jq '.SyncInfo.latest_block_height' -r) + if [ $BLOCK_HEIGHT = "$UPGRADE_HEIGHT" ]; then + # assuming running only 1 picad + echo "BLOCK HEIGHT = $UPGRADE_HEIGHT REACHED, KILLING OLD ONE" + pkill picad + break + else + ./_build/old/picad q gov proposal $UPGRADE_PROPOSAL_ID --output=json | jq ".status" + echo "BLOCK_HEIGHT = $BLOCK_HEIGHT" + sleep $SLEEP_TIME + fi + done +} + +# if FORK = true +if [[ "$FORK" == "true" ]]; then + run_fork + unset PICA_HALT_HEIGHT +else + run_upgrade +fi + +sleep 1 + +# run new node +echo -e "\n\n=> =>continue running nodes after upgrade" +#CONTINUE="true" screen -L -dmS picad bash scripts/localnode.sh _build/new/picad $DENOM +CONTINUE="true" bash scripts/localnode.sh _build/new/picad $DENOM + diff --git a/scripts/upgrade/v6_to_7/post_08_wasm.sh b/scripts/upgrade/v6_to_7/post_08_wasm.sh deleted file mode 100644 index ea03f7597..000000000 --- a/scripts/upgrade/v6_to_7/post_08_wasm.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/bash -KEY="mykey" -KEYALGO="secp256k1" -KEYRING="test" -HOME_DIR="mytestnet" - - -sleep 2 - -checksum=$(./_build/new/centaurid query ibc-wasm checksums --home $HOME_DIR -o json | jq -r '.checksums[0]') -checksum="58c7623a3ab78f4cb2e4c5d02876ac36c3b38bb472118173a7ec7faa688a66d2" - -if ./_build/new/centaurid query ibc-wasm code $checksum --home $HOME_DIR -o json &> /dev/null; then - echo "Code with checksum $checksum exists." -else - echo "Code with checksum $checksum does not exist." -fi - - diff --git a/scripts/upgrade/v6_to_7/pre_08_wasm.sh b/scripts/upgrade/v6_to_7/pre_08_wasm.sh deleted file mode 100644 index 61b1a1784..000000000 --- a/scripts/upgrade/v6_to_7/pre_08_wasm.sh +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash -KEY="mykey" -KEYALGO="secp256k1" -KEYRING="test" -HOME_DIR="mytestnet" - - - -# validate dependencies are installed -command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; } - - -stat $(pwd)/contracts/ics10_grandpa_cw.wasm -./_build/old/centaurid tx 08-wasm push-wasm $(pwd)/contracts/ics10_grandpa_cw.wasm --from=mykey --gas 10002152622 --fees 10020166ppica --keyring-backend test --chain-id=localpica -y --home $HOME_DIR - -sleep 3 - -./_build/old/centaurid query 08-wasm all-wasm-code --home $HOME_DIR \ No newline at end of file diff --git a/scripts/upgrade/v_6_6_0/pre-script.sh b/scripts/upgrade/v_6_6_0/pre-script.sh new file mode 100644 index 000000000..75eec84f8 --- /dev/null +++ b/scripts/upgrade/v_6_6_0/pre-script.sh @@ -0,0 +1,60 @@ +echo -e "\n ********** Running Pre-Scripts **********" + +BINARY=$1 +DENOM=${2:-upica} +CHAIN_DIR=$(pwd)/mytestnet + +KEY="test0" +KEY1="test1" +KEY2="test2" + + +DEFAULT_GAS_FLAG="--gas 3000000 --gas-prices 0.025$DENOM --gas-adjustment 1.5" +DEFAULT_ENV_FLAG="--keyring-backend test --chain-id localpica --home $CHAIN_DIR" + + + +echo "binary value: $BINARY" +COUNTER_CONTRACT_DIR=$(pwd)/scripts/upgrade/contracts/counter.wasm + +WALLET_1=$($BINARY keys show $KEY1 -a --keyring-backend test --home $CHAIN_DIR) +BALANCE_1=$($BINARY query bank balances $WALLET_1 --home $CHAIN_DIR -o json | jq -r '.balances[0].amount') +echo "wallet 1: $WALLET_1 - balance: $BALANCE_1" + + +############ Settingup WASM environment ############ +### Create a counter contract, then increment the counter to 1 #### +## Deploy the counter contract +TX_HASH=$($BINARY tx wasm store $COUNTER_CONTRACT_DIR --from $KEY1 $DEFAULT_ENV_FLAG $DEFAULT_GAS_FLAG -y -o json | jq -r '.txhash') + +## Get CODE ID +sleep 1 +CODE_ID=$($BINARY query tx $TX_HASH -o json | jq -r '.logs[0].events[1].attributes[1].value') +echo "code id: $CODE_ID" + +## Get contract address +# NOTE: CAN USE https://github.com/CosmWasm/wasmd/blob/9e44af168570391b0b69822952f206d35320d473/contrib/local/02-contracts.sh#L38 instantiate2 to predict address +RANDOM_HASH=$(hexdump -vn16 -e'4/4 "%08X" 1 "\n"' /dev/urandom) +TX_HASH=$($BINARY tx wasm instantiate2 $CODE_ID '{"count": 0}' $RANDOM_HASH --no-admin --label="Label with $RANDOM_HASH" --from $KEY1 $DEFAULT_ENV_FLAG $DEFAULT_GAS_FLAG -y -o json | jq -r '.txhash') + +sleep 1 +CONTRACT_ADDRESS=$($BINARY query tx $TX_HASH -o json | jq -r '.logs[0].events[1].attributes[0].value') +echo "Contract address deployed at: $CONTRACT_ADDRESS" + +## Execute the contract, increment counter to 1 +echo "wallet1: call the increment() function" +$BINARY tx wasm execute $CONTRACT_ADDRESS '{"increment":{}}' --from $KEY1 $DEFAULT_ENV_FLAG $DEFAULT_GAS_FLAG -y -o json > /dev/null + +## assert counter value to be 1 +sleep 1 +echo "wallet1: call the get_count() function" +$BINARY query wasm contract-state smart $CONTRACT_ADDRESS '{"get_count":{"addr": "'"$WALLET_1"'"}}' -o json +COUNTER_VALUE=$($BINARY query wasm contract-state smart $CONTRACT_ADDRESS '{"get_count":{"addr": "'"$WALLET_1"'"}}' -o json | jq -r '.data.count') +if [ "$COUNTER_VALUE" -ne 1 ]; then + echo "Assertion failed: Expected counter value to be 1, got $COUNTER_VALUE" + exit 1 +fi +echo "Assertion passed: Counter value is 1 as expected" + +export CONTRACT_ADDRESS=$CONTRACT_ADDRESS + diff --git a/scripts/upgrade/v_6_6_0/setup-08-wasm.sh b/scripts/upgrade/v_6_6_0/setup-08-wasm.sh new file mode 100755 index 000000000..922ea9195 --- /dev/null +++ b/scripts/upgrade/v_6_6_0/setup-08-wasm.sh @@ -0,0 +1,23 @@ +#!/bin/bash +KEY=mykey +KEYALGO="secp256k1" +KEYRING="test" +HOME_DIR="mytestnet" +BINARY=_build/old/picad +DENOM=ppica +CHAINID=centauri-dev + +$BINARY tx gov submit-proposal scripts/08-wasm/ics10_grandpa_cw.wasm.json --from=$KEY --fees 100000${DENOM} --gas auto --keyring-backend test --home $HOME_DIR --chain-id $CHAINID -y + +sleep 5 +# TODO: fetch the propsoal id dynamically +$BINARY tx gov deposit "1" "20000000ppica" --from $KEY --fees 100000${DENOM} --keyring-backend test --home $HOME_DIR --chain-id $CHAINID -y + +sleep 5 +$BINARY tx gov vote 1 yes --from $KEY --fees 100000${DENOM} --keyring-backend test --home $HOME_DIR --chain-id $CHAINID -y + + +## Voting time is 20s, check in localnode.sh +sleep 20 + +$BINARY query 08-wasm all-wasm-code --home $HOME_DIR --chain-id $CHAINID \ No newline at end of file diff --git a/scripts/upload_contracts.sh b/scripts/upload_contracts.sh index a6ffd1b3d..4cae6f1fb 100755 --- a/scripts/upload_contracts.sh +++ b/scripts/upload_contracts.sh @@ -7,4 +7,4 @@ KEYRING="test" # validate dependencies are installed command -v jq > /dev/null 2>&1 || { echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"; exit 1; } -./_build/old/centaurid tx 08-wasm push-wasm contracts/ics10_grandpa_cw.wasm --from=mykey --gas 10002152622 --fees 10020166ppica --keyring-backend test --chain-id=localpica -y \ No newline at end of file +./_build/old/centaurid tx 08-wasm push-wasm contracts/ics10_grandpa_cw.wasm --from=mykey --gas 10002152622 --fees 10020166ppica --keyring-backend test --chain-id=localpica -y diff --git a/testnode.sh b/testnode.sh index 34f2fda31..2e954e7d0 100644 --- a/testnode.sh +++ b/testnode.sh @@ -44,4 +44,4 @@ sed -i'' -e 's/max_body_bytes = /max_body_bytes = 1/g' ~/.banksy/config/config.t cat $HOME/.banksy/config/genesis.json | jq '.app_state["gov"]["params"]["voting_period"]="45s"' > $HOME/.banksy/config/tmp_genesis.json && mv $HOME/.banksy/config/tmp_genesis.json $HOME/.banksy/config/genesis.json # Start the node (remove the --pruning=nothing flag if historical queries are not needed) -# centaurid start --pruning=nothing --minimum-gas-prices=0stake +# picad start --pruning=nothing --minimum-gas-prices=0stake diff --git a/tests/interchaintest/ibc_transfer_test.go b/tests/interchaintest/ibc_transfer_test.go index 5f2ff6c71..099318f2c 100644 --- a/tests/interchaintest/ibc_transfer_test.go +++ b/tests/interchaintest/ibc_transfer_test.go @@ -97,8 +97,8 @@ func TestCentauriPicassoIBCTransfer(t *testing.T) { Name: "centauri", ChainID: "centaurid", Images: []ibc.DockerImage{CentauriImage}, - Bin: "centaurid", - Bech32Prefix: "centauri", + Bin: "picad", + Bech32Prefix: "pica", Denom: "stake", GasPrices: "0.00stake", GasAdjustment: 1.3, diff --git a/tests/interchaintest/push_wasm_client_code_test.go b/tests/interchaintest/push_wasm_client_code_test.go index 4a23cf749..14cbf4040 100644 --- a/tests/interchaintest/push_wasm_client_code_test.go +++ b/tests/interchaintest/push_wasm_client_code_test.go @@ -69,8 +69,8 @@ func TestPushWasmClientCode(t *testing.T) { Name: "centauri", ChainID: "centaurid", Images: []ibc.DockerImage{CentauriImage}, - Bin: "centaurid", - Bech32Prefix: "centauri", + Bin: "picad", + Bech32Prefix: "pica", Denom: "stake", GasPrices: "0.00stake", GasAdjustment: 1.3, diff --git a/tests/interchaintest/upgrade_chain_test.go b/tests/interchaintest/upgrade_chain_test.go index a71e92bbe..92c1952c8 100644 --- a/tests/interchaintest/upgrade_chain_test.go +++ b/tests/interchaintest/upgrade_chain_test.go @@ -43,8 +43,8 @@ func CosmosChainUpgradeTest(t *testing.T, upgradeContainerRepo, upgradeVersion, UidGid: "1025:1025", }, }, - Bin: "centaurid", - Bech32Prefix: "centauri", + Bin: "picad", + Bech32Prefix: "pica", Denom: "ppica", GasPrices: "0.00ppica", GasAdjustment: 1.3,