contracts: support changing contract upgrades policy

cli/cmd/contracts.go

@@ -305,6 +305,52 @@ var (
 			fmt.Println(string(formatted))
 		},
 	}
+
+	contractsChangeUpgradePolicyCmd = &cobra.Command{
+		Use:   "change-upgrade-policy <instance-id> <policy>",
+		Short: "Change WebAssembly smart contract upgrade policy",
+		Args:  cobra.ExactArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			cfg := cliConfig.Global()
+			npa := common.GetNPASelection(cfg)
+			txCfg := common.GetTransactionConfig()
+			strInstanceID := args[0]
+			strPolicy := args[1]
+
+			if npa.Account == nil {
+				cobra.CheckErr("no accounts configured in your wallet")
+			}
+			if npa.ParaTime == nil {
+				cobra.CheckErr("no paratimes configured")
+			}
+
+			instanceID, err := strconv.ParseUint(strInstanceID, 10, 64)
+			cobra.CheckErr(err)
+
+			// When not in offline mode, connect to the given network endpoint.
+			ctx := context.Background()
+			var conn connection.Connection
+			if !txCfg.Offline {
+				conn, err = connection.Connect(ctx, npa.Network)
+				cobra.CheckErr(err)
+			}
+
+			// Parse upgrades policy.
+			upgradesPolicy := parsePolicy(npa.Network, npa.Account, strPolicy)
+
+			// Prepare transaction.
+			tx := contracts.NewChangeUpgradePolicyTx(nil, &contracts.ChangeUpgradePolicy{
+				ID:             contracts.InstanceID(instanceID),
+				UpgradesPolicy: *upgradesPolicy,
+			})
+
+			acc := common.LoadAccount(cfg, npa.AccountName)
+			sigTx, meta, err := common.SignParaTimeTransaction(ctx, npa, acc, conn, tx)
+			cobra.CheckErr(err)
+
+			common.BroadcastTransaction(ctx, npa.ParaTime, conn, sigTx, meta, nil)
+		},
+	}
 )
 
 func formatPolicy(policy *contracts.Policy) string {
@@ -392,10 +438,14 @@ func init() {
 	contractsCallCmd.Flags().AddFlagSet(common.TransactionFlags)
 	contractsCallCmd.Flags().AddFlagSet(contractsCallFlags)
 
+	contractsChangeUpgradePolicyCmd.Flags().AddFlagSet(common.SelectorFlags)
+	contractsChangeUpgradePolicyCmd.Flags().AddFlagSet(common.TransactionFlags)
+
 	contractsCmd.AddCommand(contractsShowCmd)
 	contractsCmd.AddCommand(contractsShowCodeCmd)
 	contractsCmd.AddCommand(contractsDumpCodeCmd)
 	contractsCmd.AddCommand(contractsUploadCmd)
 	contractsCmd.AddCommand(contractsInstantiateCmd)
 	contractsCmd.AddCommand(contractsCallCmd)
+	contractsCmd.AddCommand(contractsChangeUpgradePolicyCmd)
 }

client-sdk/go/modules/contracts/contracts.go

@@ -16,10 +16,11 @@ import (
 
 const (
 	// Callable methods.
-	methodUpload      = "contracts.Upload"
-	methodInstantiate = "contracts.Instantiate"
-	methodCall        = "contracts.Call"
-	methodUpgrade     = "contracts.Upgrade"
+	methodUpload              = "contracts.Upload"
+	methodInstantiate         = "contracts.Instantiate"
+	methodCall                = "contracts.Call"
+	methodUpgrade             = "contracts.Upgrade"
+	methodChangeUpgradePolicy = "contracts.ChangeUpgradePolicy"
 
 	// Queries.
 	methodCode            = "contracts.Code"
@@ -74,6 +75,9 @@ type V1 interface {
 	// This method will encode the specified data using CBOR as defined by the Oasis ABI.
 	Upgrade(id InstanceID, codeID CodeID, data interface{}, tokens []types.BaseUnits) *client.TransactionBuilder
 
+	// ChangeUpgradePolicy generates a contracts.ChangeUpgradePolicy transaction.
+	ChangeUpgradePolicy(id InstanceID, upgradesPolicy Policy) *client.TransactionBuilder
+
 	// Code queries the given code information.
 	Code(ctx context.Context, round uint64, id CodeID) (*Code, error)
 
@@ -165,6 +169,14 @@ func (a *v1) Upgrade(id InstanceID, codeID CodeID, data interface{}, tokens []ty
 	return a.UpgradeRaw(id, codeID, cbor.Marshal(data), tokens)
 }
 
+// Implements V1.
+func (a *v1) ChangeUpgradePolicy(id InstanceID, upgradesPolicy Policy) *client.TransactionBuilder {
+	return client.NewTransactionBuilder(a.rc, methodChangeUpgradePolicy, &ChangeUpgradePolicy{
+		ID:             id,
+		UpgradesPolicy: upgradesPolicy,
+	})
+}
+
 // Implements V1.
 func (a *v1) Code(ctx context.Context, round uint64, id CodeID) (*Code, error) {
 	var code Code
@@ -318,6 +330,11 @@ func NewUpgradeTx(fee *types.Fee, body *Upgrade) *types.Transaction {
 	return types.NewTransaction(fee, methodUpgrade, body)
 }
 
+// NewChangeUpgradePolicyTx generates a new contracts.ChangeUpgradePolicy transaction.
+func NewChangeUpgradePolicyTx(fee *types.Fee, body *ChangeUpgradePolicy) *types.Transaction {
+	return types.NewTransaction(fee, methodChangeUpgradePolicy, body)
+}
+
 // CompressCode performs code compression using Snappy.
 func CompressCode(code []byte) []byte {
 	var compressedCode bytes.Buffer

client-sdk/go/modules/contracts/types.go

@@ -133,6 +133,14 @@ type Upgrade struct {
 	Tokens []types.BaseUnits `json:"tokens"`
 }
 
+// ChangeUpgradePolicy is the body of the contracts.ChangeUpgradePolicy call.
+type ChangeUpgradePolicy struct {
+	// ID is the unique instance identifier.
+	ID InstanceID `json:"id"`
+	// UpgradesPolicy is the updated upgrade policy.
+	UpgradesPolicy Policy `json:"upgrades_policy"`
+}
+
 // CodeQuery is the body of the contracts.Code query.
 type CodeQuery struct {
 	// ID is the code identifier.
@@ -210,11 +218,12 @@ type CustomQueryResult []byte
 
 // GasCosts are the contracts module gas costs.
 type GasCosts struct {
-	TxUpload        uint64 `json:"tx_upload"`
-	TxUploadPerByte uint64 `json:"tx_upload_per_byte"`
-	TxInstantiate   uint64 `json:"tx_instantiate"`
-	TxCall          uint64 `json:"tx_call"`
-	TxUpgrade       uint64 `json:"tx_upgrade"`
+	TxUpload              uint64 `json:"tx_upload"`
+	TxUploadPerByte       uint64 `json:"tx_upload_per_byte"`
+	TxInstantiate         uint64 `json:"tx_instantiate"`
+	TxCall                uint64 `json:"tx_call"`
+	TxUpgrade             uint64 `json:"tx_upgrade"`
+	TxChangeUpgradePolicy uint64 `json:"tx_change_upgrade_policy"`
 
 	SubcallDispatch uint64 `json:"subcall_dispatch"`
 

client-sdk/ts-web/rt/src/contracts.ts

@@ -32,6 +32,8 @@ export const METHOD_UPLOAD = 'contracts.Upload';
 export const METHOD_INSTANTIATE = 'contracts.Instantiate';
 export const METHOD_CALL = 'contracts.Call';
 export const METHOD_UPGRADE = 'contracts.Upgrade';
+export const METHOD_CHANGE_UPGRADE_POLICY = 'contracts.ChangeUpgradePolicy';
+
 // Queries.
 export const METHOD_CODE = 'contracts.Code';
 export const METHOD_CODE_STORAGE = 'contracts.CodeStorage';
@@ -62,6 +64,9 @@ export class Wrapper extends wrapper.Base {
     callUpgrade() {
         return this.call<types.ContractsUpgrade, void>(METHOD_UPGRADE);
     }
+    callChangeUpgradePolicy() {
+        return this.call<types.ChangeUpgradePolicy, void>(METHOD_CHANGE_UPGRADE_POLICY);
+    }
     queryCode() {
         return this.query<types.ContractsCodeQuery, types.ContractsCode>(METHOD_CODE);
     }
@@ -97,4 +102,5 @@ export type TransactionCallHandlers = {
     [METHOD_INSTANTIATE]?: transaction.CallHandler<types.ContractsInstantiate>;
     [METHOD_CALL]?: transaction.CallHandler<types.ContractsCall>;
     [METHOD_UPGRADE]?: transaction.CallHandler<types.ContractsUpgrade>;
+    [METHOD_CHANGE_UPGRADE_POLICY]?: transaction.CallHandler<types.ChangeUpgradePolicy>;
 };

client-sdk/ts-web/rt/src/types.ts

@@ -583,6 +583,20 @@ export interface ContractsUpgrade {
     tokens: BaseUnits[];
 }
 
+/**
+ * Change upgrade policy call.
+ */
+export interface ChangeUpgradePolicy {
+    /**
+     * Instance identifier.
+     */
+    id: oasis.types.longnum;
+    /**
+     * Updated contract upgrade policy.
+     */
+    upgrades_policy: ContractsPolicy;
+}
+
 /**
  * Code information query.
  */

runtime-sdk/modules/contracts/src/lib.rs

@@ -160,6 +160,7 @@ pub struct GasCosts {
     pub tx_instantiate: u64,
     pub tx_call: u64,
     pub tx_upgrade: u64,
+    pub tx_change_upgrade_policy: u64,
 
     // Subcalls.
     pub subcall_dispatch: u64,
@@ -188,6 +189,7 @@ impl Default for GasCosts {
             tx_instantiate: 0,
             tx_call: 0,
             tx_upgrade: 0,
+            tx_change_upgrade_policy: 0,
 
             subcall_dispatch: 100,
 
@@ -563,6 +565,30 @@ impl<Cfg: Config> Module<Cfg> {
         Ok(types::CallResult(data))
     }
 
+    #[handler(call = "contracts.ChangeUpgradePolicy")]
+    pub fn tx_change_upgrade_policy<C: TxContext>(
+        ctx: &mut C,
+        body: types::ChangeUpgradePolicy,
+    ) -> Result<(), Error> {
+        let params = Self::params(ctx.runtime_state());
+
+        <C::Runtime as Runtime>::Core::use_tx_gas(ctx, params.gas_costs.tx_change_upgrade_policy)?;
+
+        if ctx.is_check_only() {
+            return Ok(());
+        }
+
+        // Load instance information.
+        let mut instance_info = Self::load_instance_info(ctx, body.id)?;
+        instance_info.upgrades_policy.enforce(ctx)?;
+
+        // Change upgrade policy.
+        instance_info.upgrades_policy = body.upgrades_policy;
+        Self::store_instance_info(ctx, instance_info.clone())?;
+
+        Ok(())
+    }
+
     #[handler(call = "contracts.Upgrade")]
     pub fn tx_upgrade<C: TxContext>(ctx: &mut C, body: types::Upgrade) -> Result<(), Error> {
         let params = Self::params(ctx.runtime_state());

runtime-sdk/modules/contracts/src/test.rs

@@ -890,3 +890,90 @@ fn test_hello_contract_upgrade_fail_post() {
         );
     });
 }
+
+#[test]
+fn test_hello_contract_change_upgrade_policy() {
+    let mut mock = mock::Mock::default();
+    let mut ctx = mock.create_ctx_for_runtime::<ContractRuntime>(context::Mode::ExecuteTx);
+
+    ContractRuntime::migrate(&mut ctx);
+
+    let instance_id = deploy_hello_contract(&mut ctx, vec![]);
+
+    // Call the upgrade method.
+    let tx = transaction::Transaction {
+        version: 1,
+        call: transaction::Call {
+            format: transaction::CallFormat::Plain,
+            method: "contracts.ChangeUpgradePolicy".to_owned(),
+            body: cbor::to_value(types::ChangeUpgradePolicy {
+                id: instance_id,
+                upgrades_policy: types::Policy::Nobody,
+            }),
+            ..Default::default()
+        },
+        auth_info: transaction::AuthInfo {
+            signer_info: vec![transaction::SignerInfo::new_sigspec(
+                keys::alice::sigspec(),
+                0,
+            )],
+            fee: transaction::Fee {
+                amount: Default::default(),
+                gas: 2_000_000,
+                consensus_messages: 0,
+            },
+            ..Default::default()
+        },
+    };
+    ctx.with_tx(0, 0, tx, |mut tx_ctx, call| {
+        Contracts::tx_change_upgrade_policy(&mut tx_ctx, cbor::from_value(call.body).unwrap())
+            .expect("upgrade should succeed");
+
+        tx_ctx.commit();
+    });
+}
+
+#[test]
+fn test_hello_contract_change_upgrade_policy_fail() {
+    let mut mock = mock::Mock::default();
+    let mut ctx = mock.create_ctx_for_runtime::<ContractRuntime>(context::Mode::ExecuteTx);
+
+    ContractRuntime::migrate(&mut ctx);
+
+    let instance_id = deploy_hello_contract(&mut ctx, vec![]);
+
+    // Make Bob call the change upgrade policy method which should fail as he is not authorized.
+    let tx = transaction::Transaction {
+        version: 1,
+        call: transaction::Call {
+            format: transaction::CallFormat::Plain,
+            method: "contracts.ChangeUpgradePolicy".to_owned(),
+            body: cbor::to_value(types::ChangeUpgradePolicy {
+                id: instance_id,
+                upgrades_policy: types::Policy::Nobody,
+            }),
+            ..Default::default()
+        },
+        auth_info: transaction::AuthInfo {
+            signer_info: vec![transaction::SignerInfo::new_sigspec(
+                keys::bob::sigspec(),
+                0,
+            )],
+            fee: transaction::Fee {
+                amount: Default::default(),
+                gas: 2_000_000,
+                consensus_messages: 0,
+            },
+            ..Default::default()
+        },
+    };
+    ctx.with_tx(0, 0, tx, |mut tx_ctx, call| {
+        let result =
+            Contracts::tx_change_upgrade_policy(&mut tx_ctx, cbor::from_value(call.body).unwrap())
+                .expect_err("change upgrade policy should fail");
+
+        assert_eq!(result.module_name(), "contracts");
+        assert_eq!(result.code(), 13);
+        assert_eq!(&result.to_string(), "forbidden by policy");
+    });
+}

runtime-sdk/modules/contracts/src/types.rs

@@ -173,6 +173,16 @@ pub struct Upgrade {
     pub tokens: Vec<token::BaseUnits>,
 }
 
+/// Change upgrade policy call.
+#[derive(Clone, Debug, cbor::Encode, cbor::Decode)]
+pub struct ChangeUpgradePolicy {
+    /// Instance identifier.
+    pub id: InstanceId,
+
+    /// Updated upgrade policy.
+    pub upgrades_policy: Policy,
+}
+
 /// Code information query.
 #[derive(Clone, Debug, cbor::Encode, cbor::Decode)]
 pub struct CodeQuery {

tests/e2e/contracts.go

@@ -214,7 +214,7 @@ func ContractsTest(sc *RuntimeScenario, log *logging.Logger, conn *grpc.ClientCo
 		return fmt.Errorf("failed to watch events: %w", err)
 	}
 
-	// Tansfer some tokens.
+	// Transfer some tokens.
 	tb = ct.Call(
 		instanceOas20.ID,
 		&oas20.Request{
@@ -532,6 +532,15 @@ OUTER:
 		return fmt.Errorf("failed to get nonce: %w", err)
 	}
 
+	// Change upgrade policy.
+	tb = ct.ChangeUpgradePolicy(instanceID, contracts.Policy{Nobody: &struct{}{}}).
+		SetFeeGas(1_000_000).
+		AppendAuthSignature(testing.Alice.SigSpec, nonce)
+	_ = tb.AppendSign(ctx, signer)
+	if err = tb.SubmitTx(ctx, nil); err != nil {
+		return fmt.Errorf("failed to change upgrade policy: %w", err)
+	}
+
 	// Test signed queries.
 	tb = ct.Call(
 		instance.ID,
@@ -542,7 +551,7 @@ OUTER:
 		SetNotBefore(0).
 		SetNotAfter(100_000).
 		ReadOnly().
-		AppendAuthSignature(testing.Alice.SigSpec, nonce)
+		AppendAuthSignature(testing.Alice.SigSpec, nonce+1)
 	_ = tb.AppendSign(ctx, signer)
 	rsp, err := cr.ExecuteReadOnlyTx(ctx, client.RoundLatest, tb.GetSignedTransaction())
 	if err != nil {