Fix update proxy contracts with delete

contracts/icp/context-config/.env

@@ -2,7 +2,7 @@
 # DFX CANISTER ENVIRONMENT VARIABLES
 DFX_VERSION='0.24.2'
 DFX_NETWORK='local'
-CANISTER_ID_CONTEXT_CONTRACT='bw4dl-smaaa-aaaaa-qaacq-cai'
-CANISTER_ID='bw4dl-smaaa-aaaaa-qaacq-cai'
-CANISTER_CANDID_PATH='/Users/alen/www/calimero/core/contracts/icp/context-config/context_contract.did'
+CANISTER_ID_CONTEXT_CONTRACT='bkyz2-fmaaa-aaaaa-qaaaq-cai'
+CANISTER_ID='bkyz2-fmaaa-aaaaa-qaaaq-cai'
+CANISTER_CANDID_PATH='/Users/alen/www/calimero/core/contracts/icp/context-config/./res/calimero_context_config_icp.did'
 # END DFX CANISTER ENVIRONMENT VARIABLES

contracts/icp/context-proxy/dfx.json

@@ -1,19 +1,19 @@
 {
   "canisters": {
     "proxy_contract": {
-      "package": "calimero_context_proxy_icp",
+      "package": "calimero-context-proxy-icp",
       "candid": "./res/calimero_context_proxy_icp.did",
       "type": "rust"
     },
     "mock_ledger": {
       "type": "rust",
-      "package": "mock_ledger",
+      "package": "calimero-mock-ledger-icp",
       "candid": "./mock/ledger/res/calimero_mock_ledger_icp.did",
       "path": "mock/ledger"
     },
     "mock_external": {
       "type": "rust",
-      "package": "mock_external",
+      "package": "calimero-mock-external-icp",
       "candid": "./mock/external/res/calimero_mock_external_icp.did",
       "path": "mock/external"
     }

contracts/icp/context-proxy/res/calimero_context_proxy_icp.did

@@ -7,6 +7,7 @@ type ICProposalAction = variant {
   SetNumApprovals : record { num_approvals : nat32 };
   SetContextValue : record { key : blob; value : blob };
   Transfer : record { receiver_id : principal; amount : nat };
+  DeleteProposal : record { proposal_id : blob };
   SetActiveProposalsLimit : record { active_proposals_limit : nat32 };
   ExternalFunctionCall : record {
     receiver_id : principal;
@@ -35,8 +36,8 @@ service : (blob, principal) -> {
   get_proposal_approvals_with_signer : (blob) -> (
       vec ICProposalApprovalWithSigner,
     ) query;
-  get_proposal_approvers : (blob) -> (opt vec blob) query;
   mutate : (ICSigned) -> (Result);
   proposal : (blob) -> (opt ICProposal) query;
+  proposal_approvers : (blob) -> (opt vec blob) query;
   proposals : (nat64, nat64) -> (vec ICProposal) query;
 }

contracts/icp/context-proxy/src/mutate.rs

@@ -87,8 +87,32 @@ async fn execute_proposal(proposal_id: &ProposalId) -> Result<(), String> {
                 receiver_id,
                 method_name,
                 args,
-                deposit: _,
+                deposit,
             } => {
+                // If there's a deposit, transfer it first
+                if deposit > 0 {
+                    let ledger_id = with_state(|contract| contract.ledger_id.clone());
+
+                    let transfer_args = TransferArgs {
+                        memo: Memo(0),
+                        amount: Tokens::from_e8s(
+                            deposit
+                                .try_into()
+                                .map_err(|e| format!("Amount conversion error: {}", e))?,
+                        ),
+                        fee: Tokens::from_e8s(10_000), // Standard fee is 0.0001 ICP
+                        from_subaccount: None,
+                        to: AccountIdentifier::new(&receiver_id, &Subaccount([0; 32])),
+                        created_at_time: None,
+                    };
+
+                    let _: (Result<u64, TransferError>,) =
+                        ic_cdk::call(Principal::from(ledger_id), "transfer", (transfer_args,))
+                            .await
+                            .map_err(|e| format!("Transfer failed: {:?}", e))?;
+                }
+
+                // Then make the actual cross-contract call
                 let args_bytes = candid::encode_one(args)
                     .map_err(|e| format!("Failed to encode args: {}", e))?;
 
@@ -137,6 +161,7 @@ async fn execute_proposal(proposal_id: &ProposalId) -> Result<(), String> {
                     contract.context_storage.insert(key, value);
                 });
             }
+            ICProposalAction::DeleteProposal { proposal_id: _ } => {}
         }
     }
 
@@ -155,6 +180,14 @@ async fn internal_create_proposal(
         return Err("proposal cannot have empty actions".to_string());
     }
 
+    // Check if the proposal contains a delete action
+    for action in &proposal.actions {
+        if let ICProposalAction::DeleteProposal { proposal_id } = action {
+            remove_proposal(proposal_id);
+            return Ok(None);
+        }
+    }
+
     with_state_mut(|contract| {
         let num_proposals = contract
             .num_proposals_pk
@@ -223,6 +256,7 @@ fn validate_proposal_action(action: &ICProposalAction) -> Result<(), String> {
             }
         }
         ICProposalAction::SetContextValue { .. } => {}
+        ICProposalAction::DeleteProposal { .. } => {}
     }
     Ok(())
 }

contracts/icp/context-proxy/src/query.rs

@@ -52,7 +52,7 @@ pub fn get_confirmations_count(proposal_id: ICRepr<ProposalId>) -> Option<ICProp
 }
 
 #[ic_cdk::query]
-pub fn get_proposal_approvers(proposal_id: ICRepr<ProposalId>) -> Option<Vec<ICRepr<SignerId>>> {
+pub fn proposal_approvers(proposal_id: ICRepr<ProposalId>) -> Option<Vec<ICRepr<SignerId>>> {
     with_state(|contract| {
         contract
             .approvals

contracts/near/context-proxy/src/mutate.rs

@@ -274,11 +274,18 @@ impl ProxyContract {
 }
 
 impl ProxyContract {
-    fn propose(&self, proposal: Proposal) -> Promise {
+    fn propose(&mut self, proposal: Proposal) -> Promise {
         require!(
             !self.proposals.contains_key(&proposal.id),
             "Proposal already exists"
         );
+
+        // If this is a delete proposal, execute it immediately
+        if let Some(ProposalAction::DeleteProposal { proposal_id: _ }) = proposal.actions.first() {
+            self.remove_proposal(proposal.id);
+            return Promise::new(env::current_account_id());
+        }
+
         let author_id = proposal.author_id;
         let num_proposals = self.num_proposals_pk.get(&author_id).unwrap_or(&0) + 1;
         assert!(

crates/context/config/src/client/env/proxy/query/active_proposals.rs

@@ -65,7 +65,7 @@ impl Method<Icp> for ActiveProposalRequest {
     }
 
     fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        let value = Decode!(&response, Self::Returns)?;
-        Ok(value)
+        let value = Decode!(&response, u32)?;
+        Ok(value as u16)
     }
 }

crates/context/config/src/client/env/proxy/query/proposal_approvers.rs

@@ -104,15 +104,17 @@ impl Method<Icp> for ProposalApproversRequest {
     }
 
     fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        let identities = Decode!(&response, Vec<ICRepr<ContextIdentity>>)?;
+        let identities = Decode!(&response, Option<Vec<ICRepr<ContextIdentity>>>)?;
 
         // safety: `ICRepr<T>` is a transparent wrapper around `T`
         #[expect(
             clippy::transmute_undefined_repr,
             reason = "ICRepr<T> is a transparent wrapper around T"
         )]
         let identities = unsafe {
-            mem::transmute::<Vec<ICRepr<ContextIdentity>>, Vec<ContextIdentity>>(identities)
+            mem::transmute::<Vec<ICRepr<ContextIdentity>>, Vec<ContextIdentity>>(
+                identities.expect("error unwrapping identities"),
+            )
         };
 
         Ok(identities)

crates/context/config/src/client/env/proxy/types/starknet.rs

@@ -55,6 +55,7 @@ pub enum StarknetProposalActionWithArgs {
     SetNumApprovals(Felt),
     SetActiveProposalsLimit(Felt),
     SetContextValue(Vec<Felt>, Vec<Felt>),
+    DeleteProposal(StarknetProposalId),
 }
 
 #[derive(Debug, Encode, Decode)]
@@ -278,6 +279,9 @@ impl From<Vec<ProposalAction>> for StarknetProposalActionWithArgs {
                     value.chunks(16).map(Felt::from_bytes_be_slice).collect(),
                 )
             }
+            ProposalAction::DeleteProposal { proposal_id } => {
+                StarknetProposalActionWithArgs::DeleteProposal(proposal_id.into())
+            }
         }
     }
 }
@@ -327,6 +331,11 @@ impl From<StarknetProposalActionWithArgs> for ProposalAction {
                     value: value.iter().flat_map(|felt| felt.to_bytes_be()).collect(),
                 }
             }
+            StarknetProposalActionWithArgs::DeleteProposal(proposal_id) => {
+                ProposalAction::DeleteProposal {
+                    proposal_id: Repr::new(proposal_id.into()),
+                }
+            }
         }
     }
 }

crates/context/config/src/client/protocol/starknet.rs

@@ -278,8 +278,8 @@ impl Network {
             Ok(chain_id) => chain_id,
             Err(e) => {
                 return Err(StarknetError::Custom {
-                    operation: ErrorOperation::Query,
-                    reason: e.to_string(),
+                    operation: ErrorOperation::Mutate,
+                    reason: format!("Failed to get chain ID: {:#}", e),
                 })
             }
         };

crates/context/config/src/icp.rs

@@ -32,6 +32,9 @@ pub enum ICProposalAction {
         key: Vec<u8>,
         value: Vec<u8>,
     },
+    DeleteProposal {
+        proposal_id: ICRepr<ProposalId>,
+    },
 }
 
 impl TryFrom<ProposalAction> for ICProposalAction {
@@ -74,6 +77,9 @@ impl TryFrom<ProposalAction> for ICProposalAction {
                 key: key.into(),
                 value: value.into(),
             },
+            ProposalAction::DeleteProposal { proposal_id } => ICProposalAction::DeleteProposal {
+                proposal_id: proposal_id.rt().map_err(|e| e.to_string())?,
+            },
         };
 
         Ok(action)
@@ -114,6 +120,9 @@ impl From<ICProposalAction> for ProposalAction {
                 key: key.into_boxed_slice(),
                 value: value.into_boxed_slice(),
             },
+            ICProposalAction::DeleteProposal { proposal_id } => ProposalAction::DeleteProposal {
+                proposal_id: proposal_id.rt().expect("infallible conversion"),
+            },
         }
     }
 }

crates/context/config/src/lib.rs

@@ -156,6 +156,9 @@ pub enum ProposalAction {
         key: Box<[u8]>,
         value: Box<[u8]>,
     },
+    DeleteProposal {
+        proposal_id: Repr<ProposalId>,
+    },
 }
 
 // The proposal the user makes specifying the receiving account and actions they want to execute (1 tx)

crates/sdk/src/env/ext.rs

@@ -63,6 +63,12 @@ pub enum ProposalAction {
         /// The value to set.
         value: Box<[u8]>,
     },
+
+    /// Delete a proposal.
+    DeleteProposal {
+        /// The ID of the proposal to delete.
+        proposal_id: ProposalId,
+    },
 }
 
 /// Unique identifier for an account.
@@ -147,6 +153,14 @@ impl DraftProposal {
         self
     }
 
+    /// Add an action to delete a proposal.
+    #[must_use]
+    pub fn delete_proposal(mut self, proposal_id: ProposalId) -> Self {
+        self.actions
+            .push(ProposalAction::DeleteProposal { proposal_id });
+        self
+    }
+
     /// Finalise the proposal and send it to the blockchain.
     #[must_use]
     pub fn send(self) -> ProposalId {