Update the examples for protocol 22 support.

account/Cargo.toml

@@ -9,10 +9,10 @@ crate-type = ["cdylib"]
 doctest = false
 
 [dependencies]
-soroban-sdk = { version = "21.7.4" }
+soroban-sdk = { version = "22.0.0" }
 
 [dev-dependencies]
-soroban-sdk = { version = "21.7.4", features = ["testutils"] }
+soroban-sdk = { version = "22.0.0", features = ["testutils"] }
 ed25519-dalek = { version = "1.0.1" }
 rand = { version = "0.7.3" }
 

account/src/lib.rs

@@ -38,15 +38,16 @@ pub enum AccError {
     NegativeAmount = 2,
     BadSignatureOrder = 3,
     UnknownSigner = 4,
-    InvalidContext = 5,
 }
 
 const TRANSFER_FN: Symbol = symbol_short!("transfer");
+const APPROVE_FN: Symbol = symbol_short!("approve");
+const BURN_FN: Symbol = symbol_short!("burn");
 
 #[contractimpl]
 impl AccountContract {
     // Initialize the contract with a list of ed25519 public key ('signers').
-    pub fn init(env: Env, signers: Vec<BytesN<32>>) {
+    pub fn __constructor(env: Env, signers: Vec<BytesN<32>>) {
         // In reality this would need some additional validation on signers
         // (deduplication etc.).
         for signer in signers.iter() {
@@ -58,6 +59,9 @@ impl AccountContract {
     }
 
     // Adds a limit on any token transfers that aren't signed by every signer.
+    // For the sake of simplicity of the example the limit is only applied on
+    // a per-authorization basis; the 'real' limits should likely be time-based
+    // instead.
     pub fn add_limit(env: Env, token: Address, limit: i128) {
         // The current contract address is the account contract address and has
         // the same semantics for `require_auth` call as any other account
@@ -175,22 +179,28 @@ fn verify_authorization_policy(
     all_signed: bool,
     spend_left_per_token: &mut Map<Address, i128>,
 ) -> Result<(), AccError> {
+    // There are no limitations when every signers signs the transaction.
+    if all_signed {
+        return Ok(());
+    }
     let contract_context = match context {
         Context::Contract(c) => {
+            // Allow modifying this contract only if every signer has signed for it.
             if &c.contract == curr_contract {
-                if !all_signed {
-                    return Err(AccError::NotEnoughSigners);
-                }
+                return Err(AccError::NotEnoughSigners);
             }
             c
         }
-        Context::CreateContractHostFn(_) => return Err(AccError::InvalidContext),
+        // Allow creating new contracts only if every signer has signed for it.
+        Context::CreateContractHostFn(_) | Context::CreateContractWithCtorHostFn(_) => {
+            return Err(AccError::NotEnoughSigners);
+        }
     };
-    // For the account control every signer must sign the invocation.
 
-    // Otherwise, we're only interested in functions that spend tokens.
+    // Besides the checks above we're only interested in functions that spend tokens.
     if contract_context.fn_name != TRANSFER_FN
-        && contract_context.fn_name != Symbol::new(env, "approve")
+        && contract_context.fn_name != APPROVE_FN
+        && contract_context.fn_name != BURN_FN
     {
         return Ok(());
     }

account/src/test.rs

@@ -10,6 +10,7 @@ use soroban_sdk::testutils::Address as _;
 use soroban_sdk::testutils::AuthorizedFunction;
 use soroban_sdk::testutils::AuthorizedInvocation;
 use soroban_sdk::Val;
+use soroban_sdk::Vec;
 use soroban_sdk::{
     auth::Context, testutils::BytesN as _, vec, Address, BytesN, Env, IntoVal, Symbol,
 };
@@ -25,8 +26,8 @@ fn signer_public_key(e: &Env, signer: &Keypair) -> BytesN<32> {
     signer.public.to_bytes().into_val(e)
 }
 
-fn create_account_contract(e: &Env) -> AccountContractClient {
-    AccountContractClient::new(e, &e.register_contract(None, AccountContract {}))
+fn create_account_contract(e: &Env, signers: Vec<BytesN<32>>) -> AccountContractClient {
+    AccountContractClient::new(e, &e.register(AccountContract {}, (signers,)))
 }
 
 fn sign(e: &Env, signer: &Keypair, payload: &BytesN<32>) -> Val {
@@ -53,17 +54,18 @@ fn test_token_auth() {
     let env = Env::default();
     env.mock_all_auths();
 
-    let account_contract = create_account_contract(&env);
-
     let mut signers = [generate_keypair(), generate_keypair()];
     if signers[0].public.as_bytes() > signers[1].public.as_bytes() {
         signers.swap(0, 1);
     }
-    account_contract.init(&vec![
+    let account_contract = create_account_contract(
         &env,
-        signer_public_key(&env, &signers[0]),
-        signer_public_key(&env, &signers[1]),
-    ]);
+        vec![
+            &env,
+            signer_public_key(&env, &signers[0]),
+            signer_public_key(&env, &signers[1]),
+        ],
+    );
 
     let payload = BytesN::random(&env);
     let token = Address::generate(&env);