templar_registry_contract/
lib.rs

1#![allow(clippy::needless_pass_by_value)]
2
3mod state;
4mod storage_management;
5
6use std::ops::{Deref, DerefMut};
7
8use near_sdk::{
9    assert_one_yocto, env,
10    json_types::{Base58CryptoHash, Base64VecU8},
11    near, require,
12    store::LazyOption,
13    AccountId, CryptoHash, Gas, NearToken, PanicOnDefault, Promise, PromiseOrValue,
14};
15use near_sdk_contract_tools::{
16    owner::{Owner, OwnerExternal},
17    rbac::Rbac,
18    Owner, Rbac,
19};
20use templar_common::{
21    contract::list,
22    registry::{
23        ApprovedCode, Deployment, RegistryEntryView, RegistryEvent, Role, UploadInfo,
24        VersionAvailability, VersionInfo, VersionSource,
25    },
26    self_ext,
27    upgrade::{UpgradeSource, MIGRATE_METHOD},
28    versioned_state::{impl_versioned_state, StateVersion, VersionedState},
29    UnwrapReject,
30};
31
32type State = state::V2;
33
34#[near(serializers = [borsh])]
35pub struct Upload {
36    pub uploader: AccountId,
37    code_len: u32,
38    storage_charge: NearToken,
39    // IterableMap swap-removal must rewrite only this handle, never another upload's blob.
40    code: LazyOption<Vec<u8>>,
41}
42
43impl Upload {
44    fn new(hash: CryptoHash, uploader: AccountId, code: Vec<u8>) -> Self {
45        let code_len = u32::try_from(code.len()).unwrap_or(u32::MAX);
46        let mut code = LazyOption::new(state::StorageKey::UploadCode { hash }, Some(code));
47        // Persist the blob before its map handle; storage accounting includes both writes.
48        code.flush();
49        Self {
50            uploader,
51            code_len,
52            storage_charge: NearToken::from_yoctonear(0),
53            code,
54        }
55    }
56
57    fn into_parts(mut self) -> (AccountId, NearToken, Vec<u8>) {
58        let code = self.code.take().unwrap_or_else(|| {
59            templar_common::panic_with_message("Invariant violation: upload code is missing")
60        });
61        self.code.flush();
62        (self.uploader, self.storage_charge, code)
63    }
64
65    fn clear_code(&mut self) {
66        self.code.set(None);
67        self.code.flush();
68    }
69}
70
71#[near(serializers = [borsh])]
72pub struct StorageCharge {
73    payer: AccountId,
74    amount: NearToken,
75}
76
77#[derive(Debug, Clone)]
78#[near(serializers = [json, borsh])]
79pub enum VersionEntry {
80    Code {
81        hash: CryptoHash,
82        code: Option<Vec<u8>>,
83    },
84    GlobalHash(CryptoHash),
85}
86
87impl VersionEntry {
88    pub fn code_hash(&self) -> CryptoHash {
89        match self {
90            Self::Code { hash, .. } | Self::GlobalHash(hash) => *hash,
91        }
92    }
93
94    fn availability(&self) -> VersionAvailability {
95        match self {
96            Self::Code {
97                code: Some(code), ..
98            } => VersionAvailability::Stored {
99                // Unreachable: a stored value cannot exceed the 4 MiB storage-value limit.
100                code_len: u32::try_from(code.len()).unwrap_or(u32::MAX),
101            },
102            Self::Code { code: None, .. } => VersionAvailability::Removed,
103            Self::GlobalHash(_) => VersionAvailability::Global,
104        }
105    }
106
107    fn info(&self) -> VersionInfo {
108        VersionInfo {
109            code_hash: self.code_hash().into(),
110            availability: self.availability(),
111        }
112    }
113}
114
115#[derive(Debug, Clone)]
116#[near(serializers = [borsh])]
117pub enum RegistryEntry {
118    Reserved,
119    Deployed(Deployment),
120    /// New reservations retain their final-record budget; legacy V1 reservations have none.
121    ReservedWithStorage(NearToken),
122}
123
124impl RegistryEntry {
125    fn view(&self) -> RegistryEntryView {
126        match self {
127            Self::Reserved | Self::ReservedWithStorage(_) => RegistryEntryView::Reserved,
128            Self::Deployed(deployment) => RegistryEntryView::Deployed(deployment.clone()),
129        }
130    }
131}
132
133#[derive(PanicOnDefault, Owner, Rbac)]
134#[rbac(roles = "Role")]
135#[near(contract_state)]
136pub struct Contract {
137    pub state: VersionedState<State>,
138}
139
140// Generates the private `migrate()` entrypoint plus the `get_stored_state_version` /
141// `get_target_state_version` / `needs_migration` views.
142impl_versioned_state!(Contract, State, crate::state::Migration);
143
144// `versions` and `registry` live on `State`; deref so the methods below keep reaching them
145// directly.
146impl Deref for Contract {
147    type Target = State;
148
149    fn deref(&self) -> &Self::Target {
150        &self.state
151    }
152}
153
154impl DerefMut for Contract {
155    fn deref_mut(&mut self) -> &mut Self::Target {
156        &mut self.state
157    }
158}
159
160#[near]
161impl Contract {
162    /// Gas reserved for the batched `migrate` in [`Self::upgrade`].
163    /// Leave 90 Tgas for decoding and deploying local code, alongside the
164    /// separate 10 Tgas solvency check.
165    pub const GAS_FOR_MIGRATE: Gas = Gas::from_tgas(200);
166    const GLOBAL_PUBLISH_ACCOUNT: &str = "deploy";
167    const GLOBAL_PROBE_ACCOUNT: &str = "probe";
168
169    /// Most a single [`Self::get_version_code_chunk`] will return.
170    ///
171    /// A view's return value reaches the caller as a JSON array of one integer per byte, so the
172    /// response body runs several times the payload; this keeps it inside what RPC providers serve.
173    pub const MAX_CODE_CHUNK_LEN: u32 = 128 * 1024;
174
175    #[init]
176    pub fn new() -> Self {
177        let mut self_ = Self {
178            state: State::new(()),
179        };
180
181        self_.init(&env::predecessor_account_id());
182
183        self_
184    }
185
186    /// Explicit RBAC membership; Owner authority is checked separately by action guards.
187    pub fn has_role(&self, account_id: AccountId, role: Role) -> bool {
188        <Self as Rbac>::has_role(&account_id, &role)
189    }
190
191    fn assert_role(&self, role: Role) {
192        let predecessor = env::predecessor_account_id();
193        require!(
194            self.own_get_owner().as_ref() == Some(&predecessor)
195                || <Self as Rbac>::has_role(&predecessor, &role),
196            "Unauthorized role"
197        );
198    }
199
200    #[payable]
201    pub fn set_role(
202        &mut self,
203        account_id: AccountId,
204        role: Role,
205        set: Option<bool>,
206        allow_removing_last_member: Option<bool>,
207    ) {
208        assert_one_yocto();
209        self.assert_owner();
210        let is_granted = set.unwrap_or(true);
211        if is_granted {
212            <Self as Rbac>::add_role(self, &account_id, &role);
213        } else {
214            if !allow_removing_last_member.unwrap_or(false) {
215                require!(
216                    <Self as Rbac>::with_members_of(&role, |members| members.len()) > 1,
217                    "Cannot remove the last member of a role",
218                );
219            }
220            <Self as Rbac>::remove_role(self, &account_id, &role);
221        }
222        self.assert_storage_solvency(NearToken::from_yoctonear(0));
223        RegistryEvent::RoleSet {
224            account_id,
225            role,
226            is_granted,
227        }
228        .emit();
229    }
230
231    pub fn list_role(&self, role: Role, offset: Option<u32>, count: Option<u32>) -> Vec<AccountId> {
232        list(<Self as Rbac>::iter_members_of(&role), offset, count)
233    }
234
235    /// Stage bytes using the caller's prepaid NEP-145 available balance.
236    pub fn upload_code(&mut self, #[serializer(borsh)] code: Vec<u8>) -> Base58CryptoHash {
237        self.assert_role(Role::Uploader);
238        let hash = env::sha256_array(&code);
239        require!(!self.uploads.contains_key(&hash), "Code already uploaded");
240        let uploader = env::predecessor_account_id();
241        let storage_before = env::storage_usage();
242        let upload = Upload::new(hash, uploader.clone(), code);
243        let code_len = upload.code_len;
244        self.uploads.insert(hash, upload);
245        self.uploads.flush();
246        let charge = env::storage_byte_cost()
247            .checked_mul(u128::from(env::storage_usage() - storage_before))
248            .expect_or_reject("Upload storage cost overflow");
249        self.charge_storage(&uploader, charge);
250        self.uploads
251            .get_mut(&hash)
252            .expect_or_reject("Upload was just inserted")
253            .storage_charge = charge;
254        self.uploads.flush();
255        self.assert_storage_solvency(NearToken::from_yoctonear(0));
256        RegistryEvent::CodeUploaded {
257            code_hash: hash.into(),
258            uploader,
259            code_len,
260        }
261        .emit();
262        hash.into()
263    }
264
265    fn remove_pending_upload(&mut self, hash: &CryptoHash) -> Option<AccountId> {
266        let mut upload = self.uploads.remove(hash)?;
267        upload.clear_code();
268        self.uploads.flush();
269        self.release_storage(&upload.uploader, upload.storage_charge);
270        Some(upload.uploader)
271    }
272
273    /// Release pending storage credit to its payer; NEAR is reclaimed with `storage_withdraw`.
274    #[payable]
275    pub fn remove_upload(&mut self, code_hash: Base58CryptoHash) {
276        assert_one_yocto();
277        self.assert_role(Role::Uploader);
278        let hash: CryptoHash = code_hash.into();
279        let upload = self
280            .uploads
281            .get(&hash)
282            .unwrap_or_else(|| templar_common::panic_with_message("Upload does not exist"));
283        let predecessor = env::predecessor_account_id();
284        require!(
285            self.own_get_owner().as_ref() == Some(&predecessor) || upload.uploader == predecessor,
286            "Upload belongs to another account",
287        );
288        let uploader = self
289            .remove_pending_upload(&hash)
290            .unwrap_or_else(|| templar_common::panic_with_message("Upload does not exist"));
291        self.assert_storage_solvency(NearToken::from_yoctonear(0));
292        RegistryEvent::UploadRemoved {
293            code_hash,
294            uploader,
295        }
296        .emit();
297    }
298
299    pub fn get_upload(&self, code_hash: Base58CryptoHash) -> Option<UploadInfo> {
300        self.uploads
301            .get(&CryptoHash::from(code_hash))
302            .map(|upload| UploadInfo {
303                uploader: upload.uploader.clone(),
304                code_len: upload.code_len,
305            })
306    }
307
308    pub fn list_uploads(&self, count: Option<u32>, offset: Option<u32>) -> Vec<Base58CryptoHash> {
309        list(self.uploads.keys().copied().map(Into::into), offset, count)
310    }
311
312    /// Atomically deploy new code and run its `migrate` in one receipt, so a failed migration
313    /// reverts the deploy with it. `migrate_args` names the `state::Migration` chain to run, and is
314    /// empty when the stored state version is already the new code's.
315    ///
316    /// The only way to replace the code of a registry whose full-access keys have been removed.
317    #[payable]
318    pub fn upgrade(&mut self, code: UpgradeSource, migrate_args: Base64VecU8) -> Promise {
319        assert_one_yocto();
320        self.assert_owner();
321
322        require!(!code.is_empty_code(), "Upgrade code must not be empty");
323
324        near_sdk::log!("Upgrading registry to {:?}", code.summary());
325
326        code.deploy_and_migrate(MIGRATE_METHOD, migrate_args, Self::GAS_FOR_MIGRATE)
327            .function_call(
328                "upgrade_check_storage".to_owned(),
329                b"{}".to_vec(),
330                NearToken::ZERO,
331                Gas::from_tgas(10),
332            )
333    }
334
335    /// Runs in the deploy/migrate batch, so insufficient backing rolls back the upgrade too.
336    #[private]
337    pub fn upgrade_check_storage(&self) {
338        self.assert_storage_solvency(NearToken::ZERO);
339    }
340
341    pub fn list_versions(&self, count: Option<u32>, offset: Option<u32>) -> Vec<&String> {
342        list(self.versions.keys(), offset, count)
343    }
344
345    pub fn get_version_code_hash(&self, version_key: String) -> Option<Base58CryptoHash> {
346        self.versions
347            .get(&version_key)
348            .map(VersionEntry::code_hash)
349            .map(Into::into)
350    }
351
352    /// A registered version's hash and whether [`Self::deploy`] can still use it.
353    ///
354    /// `list_versions` keeps listing a version whose code `remove_version` cleared, and
355    /// `get_version_code_hash` keeps answering for it, so membership alone cannot tell a
356    /// deployable version from one that will panic partway through a deploy.
357    pub fn get_version(&self, version_key: String) -> Option<VersionInfo> {
358        self.versions.get(&version_key).map(VersionEntry::info)
359    }
360
361    /// Whether a name is taken, and by what.
362    ///
363    /// [`Self::deploy`] refuses any name already present, so a `Reserved` name is as unusable as a
364    /// deployed one — a state [`Self::get_deployment`] reports as absent.
365    pub fn get_registry_entry(&self, account_id: AccountId) -> Option<RegistryEntryView> {
366        self.registry.get(&account_id).map(RegistryEntry::view)
367    }
368
369    /// Bytes `[offset, offset + len)` of a version's stored code, or `None` if it has none.
370    ///
371    /// Borsh-serialized and chunked: the JSON encoding would base64 the blob and the RPC would
372    /// then re-expand it to one integer per byte. Reading a whole contract back is the last
373    /// resort anyway — [`Self::get_version`] reports the hash, which usually resolves against a
374    /// released artifact without touching this at all.
375    ///
376    /// An `offset` past the end reads empty, so a caller can loop until it stops making progress.
377    #[result_serializer(borsh)]
378    pub fn get_version_code_chunk(
379        &self,
380        version_key: String,
381        offset: u32,
382        len: u32,
383    ) -> Option<Vec<u8>> {
384        require!(
385            len <= Self::MAX_CODE_CHUNK_LEN,
386            format!("len exceeds maximum of {}", Self::MAX_CODE_CHUNK_LEN),
387        );
388
389        let code = match self.versions.get(&version_key)? {
390            VersionEntry::Code { code, .. } => code.as_ref()?,
391            VersionEntry::GlobalHash(_) => return None,
392        };
393
394        let start = (offset as usize).min(code.len());
395        let end = start.saturating_add(len as usize).min(code.len());
396
397        Some(code[start..end].to_vec())
398    }
399
400    pub fn list_deployments(&self, count: Option<u32>, offset: Option<u32>) -> Vec<&AccountId> {
401        list(
402            self.registry
403                .iter()
404                .filter(|(_, e)| matches!(e, RegistryEntry::Deployed(_)))
405                .map(|(a, _)| a),
406            offset,
407            count,
408        )
409    }
410
411    pub fn get_deployment(&self, account_id: AccountId) -> Option<&Deployment> {
412        self.registry.get(&account_id).and_then(|e| match e {
413            RegistryEntry::Reserved | RegistryEntry::ReservedWithStorage(_) => None,
414            RegistryEntry::Deployed(deployment) => Some(deployment),
415        })
416    }
417
418    /// Open a throwaway sub-account funded by the attached deposit, for a caller to act on and
419    /// then `delete_account` back into the registry.
420    ///
421    /// `prefix` separates the publish and probe accounts so a probe cannot land on an in-flight
422    /// publish.
423    fn scratch_account(prefix: &str) -> Promise {
424        let account_id: AccountId = format!("{prefix}.{}", env::current_account_id())
425            .parse()
426            .unwrap_or_else(|_| {
427                templar_common::panic_with_message("Failed to construct scratch account ID.")
428            });
429
430        Promise::new(account_id)
431            .create_account()
432            .transfer(env::attached_deposit())
433    }
434
435    /// Approve uploaded bytes or probe an existing global contract, without sending a blob.
436    #[payable]
437    pub fn approve_version(
438        &mut self,
439        version_key: String,
440        code: ApprovedCode,
441    ) -> PromiseOrValue<()> {
442        assert_one_yocto();
443        self.assert_owner();
444        require!(
445            !self.versions.contains_key(&version_key),
446            "Version key already exists",
447        );
448        match code {
449            ApprovedCode::Uploaded(hash) => {
450                let hash: CryptoHash = hash.into();
451                require!(self.uploads.contains_key(&hash), "Upload does not exist");
452                // The permanent version-key/tombstone metadata is registry-funded.
453                self.versions
454                    .insert(version_key.clone(), VersionEntry::Code { hash, code: None });
455                self.versions.flush();
456                let storage_before = env::storage_usage();
457                let upload = self
458                    .uploads
459                    .remove(&hash)
460                    .unwrap_or_else(|| templar_common::panic_with_message("Upload does not exist"));
461                let (payer, previous_charge, code) = upload.into_parts();
462                let version = VersionEntry::Code {
463                    hash,
464                    code: Some(code),
465                };
466                let info = version.info();
467                self.versions.insert(version_key.clone(), version);
468                self.version_storage.insert(
469                    version_key.clone(),
470                    StorageCharge {
471                        payer: payer.clone(),
472                        amount: NearToken::from_yoctonear(0),
473                    },
474                );
475                self.uploads.flush();
476                self.versions.flush();
477                self.version_storage.flush();
478                let storage_after = env::storage_usage();
479                let retained_charge = if storage_after >= storage_before {
480                    let growth = env::storage_byte_cost()
481                        .checked_mul(u128::from(storage_after - storage_before))
482                        .expect_or_reject("Retained storage cost overflow");
483                    self.charge_storage(&payer, growth);
484                    previous_charge.checked_add(growth)
485                } else {
486                    let released = env::storage_byte_cost()
487                        .checked_mul(u128::from(storage_before - storage_after))
488                        .expect_or_reject("Released storage cost overflow");
489                    self.release_storage(&payer, released);
490                    previous_charge.checked_sub(released)
491                }
492                .expect_or_reject("Invariant violation: retained upload storage charge");
493                self.version_storage
494                    .get_mut(&version_key)
495                    .expect_or_reject("Version storage payer was just inserted")
496                    .amount = retained_charge;
497                self.version_storage.flush();
498                self.assert_storage_solvency(NearToken::from_yoctonear(0));
499                RegistryEvent::VersionAdded { version_key, info }.emit();
500                PromiseOrValue::Value(())
501            }
502            ApprovedCode::Global(hash) => {
503                self.add_version(version_key, VersionSource::ExistingGlobal(hash))
504            }
505        }
506    }
507
508    fn finish_version(&mut self, version_key: String, info: VersionInfo) {
509        self.versions.flush();
510        let _ = self.remove_pending_upload(&CryptoHash::from(info.code_hash));
511        self.assert_storage_solvency(NearToken::from_yoctonear(0));
512        RegistryEvent::VersionAdded { version_key, info }.emit();
513    }
514
515    #[payable]
516    pub fn add_version(
517        &mut self,
518        #[serializer(borsh)] version_key: String,
519        #[serializer(borsh)] source: VersionSource,
520    ) -> PromiseOrValue<()> {
521        self.assert_owner();
522        require!(
523            !self.versions.contains_key(&version_key),
524            "Version key already exists",
525        );
526
527        match source {
528            VersionSource::Stored(code) => {
529                assert_one_yocto();
530                let version_entry = VersionEntry::Code {
531                    hash: env::sha256_array(&code.0),
532                    code: Some(code.0),
533                };
534                let info = version_entry.info();
535                self.versions.insert(version_key.clone(), version_entry);
536                self.finish_version(version_key, info);
537                PromiseOrValue::Value(())
538            }
539            VersionSource::PublishGlobal(code) => {
540                require!(
541                    !env::attached_deposit().is_zero(),
542                    "Deposit required to pay for global contract deployment",
543                );
544                let version_entry = VersionEntry::GlobalHash(env::sha256_array(&code.0));
545                self.versions.insert(version_key.clone(), version_entry);
546                self.versions.flush();
547                self.assert_storage_solvency(env::attached_deposit());
548                PromiseOrValue::Promise(
549                    Self::scratch_account(Self::GLOBAL_PUBLISH_ACCOUNT)
550                        .deploy_global_contract(code.0)
551                        .delete_account(env::current_account_id())
552                        .then(self_ext!(Gas::from_tgas(20)).add_version_01_finalize(version_key)),
553                )
554            }
555            // The hash is verified, not trusted: a hash with no global contract behind it fails
556            // this receipt and `add_version_01_finalize` frees the key again. Without the probe an
557            // unverified typo would burn the key permanently, since `remove_version` panics on a
558            // `GlobalHash` entry.
559            VersionSource::ExistingGlobal(hash) => {
560                // One yocto, as for `Stored`: the probe account is created and deleted inside a
561                // single receipt, so it never has to satisfy a storage-staking minimum, and
562                // `use_global_contract` copies no code to stake for. The cost here is gas.
563                assert_one_yocto();
564                self.versions
565                    .insert(version_key.clone(), VersionEntry::GlobalHash(hash.into()));
566                self.versions.flush();
567                self.assert_storage_solvency(env::attached_deposit());
568                PromiseOrValue::Promise(
569                    Self::scratch_account(Self::GLOBAL_PROBE_ACCOUNT)
570                        .use_global_contract(hash)
571                        .delete_account(env::current_account_id())
572                        .then(self_ext!(Gas::from_tgas(20)).add_version_01_finalize(version_key)),
573                )
574            }
575        }
576    }
577
578    #[private]
579    pub fn add_version_01_finalize(&mut self, version_key: String) -> PromiseOrValue<()> {
580        let result = env::promise_result_checked(0, 0x1000);
581        if result.is_ok() {
582            if let Some(info) = self.versions.get(&version_key).map(VersionEntry::info) {
583                self.finish_version(version_key, info);
584            }
585            PromiseOrValue::Value(())
586        } else {
587            self.versions.remove(&version_key);
588            self.versions.flush();
589            // This only releases the provisional key. An existing backing
590            // shortfall must not roll back failed-global cleanup.
591            PromiseOrValue::Promise(
592                self_ext!(Gas::from_tgas(1)).fail("Failed to deploy global contract".to_string()),
593            )
594        }
595    }
596
597    #[payable]
598    pub fn remove_version(&mut self, version_key: String) {
599        assert_one_yocto();
600        self.assert_owner();
601
602        match self.versions.get_mut(&version_key) {
603            None | Some(VersionEntry::Code { code: None, .. }) => {}
604            Some(VersionEntry::Code { hash, code }) => {
605                *code = None;
606                let code_hash = (*hash).into();
607                self.versions.flush();
608                if let Some(charge) = self.version_storage.remove(&version_key) {
609                    self.version_storage.flush();
610                    self.release_storage(&charge.payer, charge.amount);
611                }
612                self.assert_storage_solvency(NearToken::from_yoctonear(0));
613                RegistryEvent::VersionRemoved {
614                    version_key,
615                    code_hash,
616                }
617                .emit();
618            }
619            Some(VersionEntry::GlobalHash(_)) => {
620                templar_common::panic_with_message("Global contract cannot be removed")
621            }
622        }
623    }
624
625    #[payable]
626    pub fn deploy(
627        &mut self,
628        name: String,
629        version_key: String,
630        init_args: Base64VecU8,
631        full_access_keys: Option<Vec<near_sdk::PublicKey>>,
632    ) -> Promise {
633        require!(!name.is_empty(), "Name must not be empty");
634        self.assert_role(Role::Deployer);
635        let full_access_keys = full_access_keys.unwrap_or_default();
636        require!(
637            !matches!(
638                name.as_str(),
639                Self::GLOBAL_PROBE_ACCOUNT | Self::GLOBAL_PUBLISH_ACCOUNT
640            ),
641            "Deployment name is reserved",
642        );
643
644        // Through `Deref` every field access borrows the whole contract, so the read of `versions`
645        // held across the write to `registry` needs them named as the disjoint fields they are.
646        let state = &mut *self.state;
647
648        let Some(version) = state.versions.get(&version_key) else {
649            templar_common::panic_with_message("Version key does not exist");
650        };
651
652        let attached_deposit = env::attached_deposit();
653
654        let current_account_id = env::current_account_id();
655        let account_id: AccountId = format!("{name}.{current_account_id}")
656            .parse()
657            .unwrap_or_else(|_| {
658                templar_common::panic_with_message("Deployment name is not a valid account ID")
659            });
660
661        require!(
662            account_id.is_sub_account_of(&current_account_id),
663            "Deployment account cannot be created",
664        );
665
666        require!(
667            !state.registry.contains_key(&account_id),
668            // templar-backend's relayer matches this text verbatim until ENG-781.
669            "Market ID collision",
670        );
671
672        let deployment = Deployment {
673            version_key,
674            code_hash: version.code_hash().into(),
675            block_height: env::block_height().into(),
676        };
677        let final_bytes = near_sdk::borsh::object_length(&deployment).unwrap_or_reject();
678        let reserved_bytes = near_sdk::borsh::object_length(&NearToken::ZERO).unwrap_or_reject();
679        let storage_reserve = env::storage_byte_cost()
680            .checked_mul(
681                u128::try_from(
682                    final_bytes
683                        .checked_sub(reserved_bytes)
684                        .expect_or_reject("Invariant violation: deployment storage reserve"),
685                )
686                .unwrap_or_reject(),
687            )
688            .expect_or_reject("Deployment storage reserve overflow");
689        state.pending_deployment_storage = state
690            .pending_deployment_storage
691            .checked_add(storage_reserve)
692            .expect_or_reject("Deployment reserve overflow");
693        state.registry.insert(
694            account_id.clone(),
695            RegistryEntry::ReservedWithStorage(storage_reserve),
696        );
697
698        near_sdk::log!("Deploying {} to {account_id}", deployment.version_key);
699
700        let mut promise = Promise::new(account_id.clone())
701            .create_account()
702            .transfer(env::attached_deposit());
703
704        match version {
705            VersionEntry::Code { code, .. } => {
706                let code = code.as_ref().unwrap_or_else(|| {
707                    templar_common::panic_with_message("Version code has been deleted")
708                });
709
710                let minimum_deposit = env::storage_byte_cost().saturating_mul(code.len() as u128);
711
712                require!(
713                    attached_deposit >= minimum_deposit,
714                    format!("Insufficient deposit to pay for storage (minimum: {minimum_deposit})"),
715                );
716
717                promise = promise.deploy_contract(code.clone());
718            }
719            VersionEntry::GlobalHash(hash) => promise = promise.use_global_contract(*hash),
720        }
721
722        promise = add_full_access_keys(promise, &full_access_keys);
723
724        let promise = promise
725            .function_call_weight(
726                "new".to_string(),
727                init_args.0,
728                NearToken::from_near(0),
729                Gas::from_tgas(2),
730                near_sdk::GasWeight(20),
731            )
732            .then(
733                Self::ext(env::current_account_id())
734                    .with_unused_gas_weight(1)
735                    .with_static_gas(Gas::from_tgas(2))
736                    .deploy_01_finalize(
737                        Some(account_id),
738                        None,
739                        deployment,
740                        Some(env::predecessor_account_id()),
741                        Some(full_access_keys),
742                    ),
743            );
744        self.registry.flush();
745        self.assert_storage_solvency(attached_deposit);
746        promise
747    }
748
749    #[private]
750    pub fn deploy_01_finalize(
751        &mut self,
752        account_id: Option<AccountId>,
753        // 2.0.0's name for `account_id`, so its callbacks still in flight across the upgrade land.
754        market_id: Option<AccountId>,
755        deployment: Deployment,
756        // Option fields deserialize missing 2.0.0 provenance as None and emit null.
757        deployer: Option<AccountId>,
758        full_access_keys: Option<Vec<near_sdk::PublicKey>>,
759    ) -> PromiseOrValue<AccountId> {
760        let Some(account_id) = account_id.or(market_id) else {
761            templar_common::panic_with_message("Missing deployment account ID");
762        };
763        if let Some(RegistryEntry::ReservedWithStorage(reserve)) = self.registry.get(&account_id) {
764            self.pending_deployment_storage = self
765                .pending_deployment_storage
766                .checked_sub(*reserve)
767                .expect_or_reject("Invariant violation: deployment reserve underflow");
768        }
769        let successful = env::promise_result_checked(0, 0x1000).is_ok();
770
771        if successful {
772            self.registry.insert(
773                account_id.clone(),
774                RegistryEntry::Deployed(deployment.clone()),
775            );
776            self.registry.flush();
777            self.assert_storage_solvency(NearToken::from_yoctonear(0));
778            RegistryEvent::Deployed {
779                account_id: account_id.clone(),
780                deployment,
781                deployer,
782                full_access_keys,
783            }
784            .emit();
785            PromiseOrValue::Value(account_id)
786        } else {
787            self.registry.remove(&account_id);
788            self.registry.flush();
789            // This only releases storage and the held reserve. An existing
790            // backing shortfall must not roll back failed-deployment cleanup.
791
792            PromiseOrValue::Promise(
793                Self::ext(env::current_account_id()).fail("Deployment failed".to_string()),
794            )
795        }
796    }
797
798    #[private]
799    pub fn fail(&self, message: String) {
800        templar_common::panic_with_message(&message);
801    }
802}
803
804fn add_full_access_keys(mut promise: Promise, full_access_keys: &[near_sdk::PublicKey]) -> Promise {
805    for key in full_access_keys {
806        near_sdk::log!(
807            "WARNING: Deploying with full-access key {}",
808            String::from(key),
809        );
810        promise = promise.add_full_access_key(key.clone());
811    }
812    promise
813}
814
815#[cfg(test)]
816mod tests {
817    use near_sdk::{
818        mock::MockAction,
819        serde_json,
820        test_utils::{get_created_receipts, get_logs, VMContextBuilder},
821        testing_env, PromiseResult,
822    };
823    use rstest::rstest;
824
825    use super::*;
826
827    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
828    enum Identity {
829        Owner,
830        Uploader,
831        Deployer,
832        Both,
833        Unrelated,
834    }
835
836    impl Identity {
837        fn account(self) -> AccountId {
838            match self {
839                Self::Owner => "owner.near",
840                Self::Uploader => "uploader.near",
841                Self::Deployer => "deployer.near",
842                Self::Both => "both.near",
843                Self::Unrelated => "unrelated.near",
844            }
845            .parse()
846            .unwrap()
847        }
848    }
849
850    fn authorized_contract(identity: Identity, deposit: NearToken) -> Contract {
851        testing_env!(VMContextBuilder::new()
852            .predecessor_account_id(Identity::Owner.account())
853            .build());
854        let mut contract = Contract::new();
855        for (account, roles) in [
856            (Identity::Uploader, &[Role::Uploader][..]),
857            (Identity::Deployer, &[Role::Deployer][..]),
858            (Identity::Both, &[Role::Uploader, Role::Deployer][..]),
859        ] {
860            for role in roles {
861                <Contract as Rbac>::add_role(&mut contract, &account.account(), role);
862            }
863        }
864        for account in [
865            Identity::Owner,
866            Identity::Uploader,
867            Identity::Deployer,
868            Identity::Both,
869            Identity::Unrelated,
870        ] {
871            fund_storage(&mut contract, account.account());
872        }
873        testing_env!(VMContextBuilder::new()
874            .storage_usage(env::storage_usage())
875            .signer_account_id(Identity::Owner.account())
876            .predecessor_account_id(identity.account())
877            .attached_deposit(deposit)
878            .build());
879        contract
880    }
881
882    fn fund_storage(contract: &mut Contract, payer: AccountId) {
883        testing_env!(VMContextBuilder::new()
884            .storage_usage(env::storage_usage())
885            .predecessor_account_id(payer)
886            .attached_deposit(NearToken::from_near(1))
887            .build());
888        contract.storage_deposit(None, None);
889    }
890
891    fn stage_upload(contract: &mut Contract, payer: AccountId, code: Vec<u8>) {
892        let predecessor = env::predecessor_account_id();
893        let signer = env::signer_account_id();
894        let attached = env::attached_deposit();
895        let explicit_role = <Contract as Rbac>::has_role(&payer, &Role::Uploader);
896        if !explicit_role {
897            <Contract as Rbac>::add_role(contract, &payer, &Role::Uploader);
898        }
899        contract.versions.flush();
900        testing_env!(VMContextBuilder::new()
901            .storage_usage(env::storage_usage())
902            .predecessor_account_id(payer.clone())
903            .build());
904        contract.upload_code(code);
905        if !explicit_role {
906            <Contract as Rbac>::remove_role(contract, &payer, &Role::Uploader);
907        }
908        testing_env!(VMContextBuilder::new()
909            .storage_usage(env::storage_usage())
910            .predecessor_account_id(predecessor)
911            .signer_account_id(signer)
912            .attached_deposit(attached)
913            .build());
914    }
915
916    fn assert_panics(message: &str, action: impl FnOnce()) {
917        let error = std::panic::catch_unwind(std::panic::AssertUnwindSafe(action)).unwrap_err();
918        let actual = error
919            .downcast_ref::<String>()
920            .map(String::as_str)
921            .or_else(|| error.downcast_ref::<&str>().copied())
922            .unwrap();
923        assert!(
924            actual.contains(message),
925            "expected {message:?}, got {actual:?}"
926        );
927    }
928
929    #[derive(Clone, Copy, Debug)]
930    enum AdminMethod {
931        ApproveUploaded,
932        ApproveGlobal,
933        AddStored,
934        AddPublishGlobal,
935        AddExistingGlobal,
936        RemoveVersion,
937        Upgrade,
938        GrantRole,
939        RevokeRole,
940        ProposeOwner,
941    }
942
943    fn call_admin(contract: &mut Contract, method: AdminMethod) {
944        let hash = env::sha256_array([42]);
945        match method {
946            AdminMethod::ApproveUploaded => {
947                let _ =
948                    contract.approve_version("new".to_owned(), ApprovedCode::Uploaded(hash.into()));
949            }
950            AdminMethod::ApproveGlobal => {
951                let _ =
952                    contract.approve_version("new".to_owned(), ApprovedCode::Global(hash.into()));
953            }
954            AdminMethod::AddStored => {
955                let _ =
956                    contract.add_version("new".to_owned(), VersionSource::Stored(vec![42].into()));
957            }
958            AdminMethod::AddPublishGlobal => {
959                let _ = contract.add_version(
960                    "new".to_owned(),
961                    VersionSource::PublishGlobal(vec![42].into()),
962                );
963            }
964            AdminMethod::AddExistingGlobal => {
965                let _ = contract
966                    .add_version("new".to_owned(), VersionSource::ExistingGlobal(hash.into()));
967            }
968            AdminMethod::RemoveVersion => contract.remove_version("existing".to_owned()),
969            AdminMethod::Upgrade => contract
970                .upgrade(UpgradeSource::Code(vec![42].into()), vec![].into())
971                .detach(),
972            AdminMethod::GrantRole => {
973                contract.set_role(
974                    Identity::Unrelated.account(),
975                    Role::Uploader,
976                    Some(true),
977                    None,
978                );
979            }
980            AdminMethod::RevokeRole => {
981                contract.set_role(
982                    Identity::Uploader.account(),
983                    Role::Uploader,
984                    Some(false),
985                    Some(true),
986                );
987            }
988            AdminMethod::ProposeOwner => {
989                contract.own_propose_owner(Some(Identity::Unrelated.account()));
990            }
991        }
992    }
993
994    #[rstest]
995    fn admin_methods_reject_hot_roles(
996        #[values(
997            Identity::Owner,
998            Identity::Uploader,
999            Identity::Deployer,
1000            Identity::Both,
1001            Identity::Unrelated
1002        )]
1003        identity: Identity,
1004        #[values(
1005            AdminMethod::ApproveUploaded,
1006            AdminMethod::ApproveGlobal,
1007            AdminMethod::AddStored,
1008            AdminMethod::AddPublishGlobal,
1009            AdminMethod::AddExistingGlobal,
1010            AdminMethod::RemoveVersion,
1011            AdminMethod::Upgrade,
1012            AdminMethod::GrantRole,
1013            AdminMethod::RevokeRole,
1014            AdminMethod::ProposeOwner
1015        )]
1016        method: AdminMethod,
1017    ) {
1018        let mut contract = authorized_contract(identity, NearToken::from_yoctonear(1));
1019        let hash = env::sha256_array([42]);
1020        stage_upload(&mut contract, Identity::Uploader.account(), vec![42]);
1021        contract.versions.insert(
1022            "existing".to_owned(),
1023            VersionEntry::Code {
1024                hash: [8; 32],
1025                code: Some(vec![8]),
1026            },
1027        );
1028        if identity == Identity::Owner {
1029            call_admin(&mut contract, method);
1030            match method {
1031                AdminMethod::ApproveUploaded | AdminMethod::AddStored => assert_eq!(
1032                    contract.get_version("new".to_owned()).unwrap().availability,
1033                    VersionAvailability::Stored { code_len: 1 }
1034                ),
1035                AdminMethod::ApproveGlobal
1036                | AdminMethod::AddPublishGlobal
1037                | AdminMethod::AddExistingGlobal => assert_eq!(
1038                    contract.get_version("new".to_owned()).unwrap().availability,
1039                    VersionAvailability::Global
1040                ),
1041                AdminMethod::RemoveVersion => assert_eq!(
1042                    contract
1043                        .get_version("existing".to_owned())
1044                        .unwrap()
1045                        .availability,
1046                    VersionAvailability::Removed
1047                ),
1048                AdminMethod::GrantRole => {
1049                    assert!(contract.has_role(Identity::Unrelated.account(), Role::Uploader));
1050                }
1051                AdminMethod::RevokeRole => {
1052                    assert!(!contract.has_role(Identity::Uploader.account(), Role::Uploader));
1053                }
1054                AdminMethod::ProposeOwner => assert_eq!(
1055                    contract.own_get_proposed_owner(),
1056                    Some(Identity::Unrelated.account())
1057                ),
1058                AdminMethod::Upgrade => {}
1059            }
1060        } else {
1061            assert_panics("Owner only", || call_admin(&mut contract, method));
1062            assert_eq!(contract.get_version("new".to_owned()), None);
1063            assert_eq!(
1064                contract.get_upload(hash.into()).unwrap().uploader,
1065                Identity::Uploader.account()
1066            );
1067            assert_eq!(
1068                contract
1069                    .get_version("existing".to_owned())
1070                    .unwrap()
1071                    .availability,
1072                VersionAvailability::Stored { code_len: 1 }
1073            );
1074            assert_eq!(contract.own_get_proposed_owner(), None);
1075            assert!(contract.has_role(Identity::Uploader.account(), Role::Uploader));
1076            assert!(!contract.has_role(Identity::Unrelated.account(), Role::Uploader));
1077            assert!(emitted_events().is_empty());
1078            assert!(get_created_receipts().is_empty());
1079        }
1080    }
1081
1082    #[rstest]
1083    fn admin_confirmation_deposits_are_exact(
1084        #[values(0, 2)] deposit: u128,
1085        #[values(
1086            AdminMethod::ApproveUploaded,
1087            AdminMethod::ApproveGlobal,
1088            AdminMethod::AddStored,
1089            AdminMethod::AddExistingGlobal,
1090            AdminMethod::RemoveVersion,
1091            AdminMethod::Upgrade,
1092            AdminMethod::GrantRole,
1093            AdminMethod::RevokeRole,
1094            AdminMethod::ProposeOwner
1095        )]
1096        method: AdminMethod,
1097    ) {
1098        let mut contract = authorized_contract(Identity::Owner, NearToken::from_yoctonear(deposit));
1099        assert_panics("Requires attached deposit of exactly 1 yoctoNEAR", || {
1100            call_admin(&mut contract, method);
1101        });
1102    }
1103
1104    #[rstest]
1105    fn uploader_methods_follow_current_predecessor_roles(
1106        #[values(
1107            Identity::Owner,
1108            Identity::Uploader,
1109            Identity::Deployer,
1110            Identity::Both,
1111            Identity::Unrelated
1112        )]
1113        identity: Identity,
1114    ) {
1115        let mut contract = authorized_contract(identity, NearToken::ZERO);
1116        let hash = env::sha256_array([42]);
1117        let allowed = matches!(
1118            identity,
1119            Identity::Owner | Identity::Uploader | Identity::Both
1120        );
1121        if allowed {
1122            assert_eq!(contract.upload_code(vec![42]), Base58CryptoHash::from(hash));
1123            assert_eq!(
1124                contract.get_upload(hash.into()).unwrap().uploader,
1125                identity.account()
1126            );
1127            testing_env!(VMContextBuilder::new()
1128                .predecessor_account_id(identity.account())
1129                .attached_deposit(NearToken::from_yoctonear(1))
1130                .build());
1131            contract.remove_upload(hash.into());
1132            assert_eq!(contract.get_upload(hash.into()), None);
1133            assert!(get_created_receipts().is_empty());
1134        } else {
1135            assert_panics("Unauthorized role", || {
1136                contract.upload_code(vec![42]);
1137            });
1138            assert!(contract.uploads.is_empty());
1139            contract
1140                .uploads
1141                .insert(hash, Upload::new(hash, identity.account(), vec![42]));
1142            testing_env!(VMContextBuilder::new()
1143                .predecessor_account_id(identity.account())
1144                .attached_deposit(NearToken::from_yoctonear(1))
1145                .build());
1146            assert_panics("Unauthorized role", || contract.remove_upload(hash.into()));
1147            assert!(contract.get_upload(hash.into()).is_some());
1148        }
1149    }
1150
1151    #[rstest]
1152    fn only_proposed_owner_can_accept(
1153        #[values(
1154            Identity::Owner,
1155            Identity::Uploader,
1156            Identity::Deployer,
1157            Identity::Both,
1158            Identity::Unrelated
1159        )]
1160        identity: Identity,
1161    ) {
1162        let mut contract = authorized_contract(identity, NearToken::from_yoctonear(1));
1163        <Contract as Owner>::update_proposed_unchecked(
1164            &mut contract,
1165            Some(Identity::Unrelated.account()),
1166        );
1167        if identity == Identity::Unrelated {
1168            contract.own_accept_owner();
1169            assert_eq!(contract.own_get_owner(), Some(identity.account()));
1170            assert_eq!(contract.own_get_proposed_owner(), None);
1171        } else {
1172            assert_panics("Proposed owner only", || contract.own_accept_owner());
1173            assert_eq!(contract.own_get_owner(), Some(Identity::Owner.account()));
1174        }
1175    }
1176
1177    #[rstest]
1178    fn upload_removal_checks_recorded_uploader_and_current_role(
1179        #[values(Identity::Owner, Identity::Uploader, Identity::Both)] identity: Identity,
1180    ) {
1181        let mut contract = authorized_contract(identity, NearToken::from_yoctonear(1));
1182        let hash = env::sha256_array([42]);
1183        stage_upload(&mut contract, Identity::Unrelated.account(), vec![42]);
1184        if identity == Identity::Owner {
1185            contract.remove_upload(hash.into());
1186            assert_eq!(contract.get_upload(hash.into()), None);
1187        } else {
1188            assert_panics("Upload belongs to another account", || {
1189                contract.remove_upload(hash.into());
1190            });
1191            assert!(contract.get_upload(hash.into()).is_some());
1192            <Contract as Rbac>::remove_role(&mut contract, &identity.account(), &Role::Uploader);
1193            assert_panics("Unauthorized role", || contract.remove_upload(hash.into()));
1194            assert!(contract.get_upload(hash.into()).is_some());
1195            if identity == Identity::Both {
1196                assert!(contract.has_role(identity.account(), Role::Deployer));
1197            }
1198        }
1199    }
1200
1201    #[rstest]
1202    fn uploader_confirmation_deposits_are_exact(#[values(0, 2)] deposit: u128) {
1203        let mut contract = authorized_contract(Identity::Owner, NearToken::from_yoctonear(deposit));
1204        assert_panics("Requires attached deposit of exactly 1 yoctoNEAR", || {
1205            contract.remove_upload([0; 32].into());
1206        });
1207        assert_panics("Requires attached deposit of exactly 1 yoctoNEAR", || {
1208            contract.own_accept_owner();
1209        });
1210    }
1211
1212    #[rstest]
1213    fn duplicate_uploads_do_not_replace_recorded_uploader(
1214        #[values(Identity::Owner, Identity::Uploader, Identity::Both)] identity: Identity,
1215    ) {
1216        let mut contract = authorized_contract(identity, NearToken::from_near(1));
1217        let hash = env::sha256_array([42]);
1218        contract.uploads.insert(
1219            hash,
1220            Upload::new(hash, Identity::Uploader.account(), vec![42]),
1221        );
1222        assert_panics("Code already uploaded", || {
1223            contract.upload_code(vec![42]);
1224        });
1225        assert_eq!(
1226            contract.get_upload(hash.into()).unwrap().uploader,
1227            Identity::Uploader.account()
1228        );
1229    }
1230
1231    #[test]
1232    fn missing_or_occupied_approval_never_consumes_another_upload() {
1233        let mut contract = authorized_contract(Identity::Owner, NearToken::from_yoctonear(1));
1234        let hash = env::sha256_array([42]);
1235        stage_upload(&mut contract, Identity::Uploader.account(), vec![42]);
1236        let _ =
1237            contract.approve_version("occupied".to_owned(), ApprovedCode::Uploaded(hash.into()));
1238        contract.uploads.insert(
1239            [9; 32],
1240            Upload::new([9; 32], Identity::Uploader.account(), vec![9]),
1241        );
1242        assert_panics("Version key already exists", || {
1243            let _ = contract.approve_version(
1244                "occupied".to_owned(),
1245                ApprovedCode::Uploaded([9; 32].into()),
1246            );
1247        });
1248        assert!(contract.get_upload([9; 32].into()).is_some());
1249        assert_panics("Upload does not exist", || {
1250            let _ =
1251                contract.approve_version("free".to_owned(), ApprovedCode::Uploaded([8; 32].into()));
1252        });
1253        assert_eq!(contract.get_version("free".to_owned()), None);
1254        assert_panics("Upload does not exist", || {
1255            contract.remove_upload([8; 32].into());
1256        });
1257    }
1258
1259    #[rstest]
1260    fn views_are_public_and_report_explicit_membership(
1261        #[values(
1262            Identity::Owner,
1263            Identity::Uploader,
1264            Identity::Deployer,
1265            Identity::Both,
1266            Identity::Unrelated
1267        )]
1268        identity: Identity,
1269    ) {
1270        use templar_common::versioned_state::MigrateExternalInterface;
1271        let mut contract = authorized_contract(identity, NearToken::ZERO);
1272        assert_eq!(Contract::get_stored_state_version(), 2);
1273        assert_eq!(Contract::get_target_state_version(), 2);
1274        assert!(!Contract::needs_migration());
1275        assert_eq!(contract.own_get_owner(), Some(Identity::Owner.account()));
1276        assert_eq!(contract.own_get_proposed_owner(), None);
1277        assert!(!contract.has_role(Identity::Owner.account(), Role::Uploader));
1278        assert!(!contract.has_role(Identity::Owner.account(), Role::Deployer));
1279        assert_eq!(
1280            contract.list_role(Role::Uploader, None, None),
1281            [Identity::Uploader.account(), Identity::Both.account()]
1282        );
1283        assert_eq!(
1284            contract.list_role(Role::Deployer, Some(1), Some(1)),
1285            [Identity::Both.account()]
1286        );
1287        assert!(contract.list_uploads(None, None).is_empty());
1288        assert!(contract.list_versions(None, None).is_empty());
1289        assert!(contract.list_deployments(None, None).is_empty());
1290        assert_eq!(contract.get_upload([1; 32].into()), None);
1291        assert_eq!(contract.get_version("missing".to_owned()), None);
1292        assert_eq!(contract.get_version_code_hash("missing".to_owned()), None);
1293        assert_eq!(
1294            contract.get_version_code_chunk("missing".to_owned(), 0, 1),
1295            None
1296        );
1297        assert_eq!(
1298            contract.get_registry_entry(Identity::Unrelated.account()),
1299            None
1300        );
1301        assert_eq!(contract.get_deployment(Identity::Unrelated.account()), None);
1302        contract.versions.insert(
1303            "version".to_owned(),
1304            VersionEntry::Code {
1305                hash: [1; 32],
1306                code: Some(vec![1, 2]),
1307            },
1308        );
1309        contract.uploads.insert(
1310            [2; 32],
1311            Upload::new([2; 32], Identity::Uploader.account(), vec![3]),
1312        );
1313        let deployed = Deployment {
1314            version_key: "version".to_owned(),
1315            code_hash: [1; 32].into(),
1316            block_height: 7.into(),
1317        };
1318        contract.registry.insert(
1319            Identity::Unrelated.account(),
1320            RegistryEntry::Deployed(deployed.clone()),
1321        );
1322        assert_eq!(
1323            contract.get_version("version".to_owned()),
1324            Some(VersionInfo {
1325                code_hash: [1; 32].into(),
1326                availability: VersionAvailability::Stored { code_len: 2 },
1327            })
1328        );
1329        assert_eq!(
1330            contract.get_version_code_hash("version".to_owned()),
1331            Some([1; 32].into())
1332        );
1333        assert_eq!(
1334            contract.get_version_code_chunk("version".to_owned(), 1, 2),
1335            Some(vec![2])
1336        );
1337        assert_eq!(
1338            contract.get_upload([2; 32].into()),
1339            Some(UploadInfo {
1340                uploader: Identity::Uploader.account(),
1341                code_len: 1
1342            })
1343        );
1344        assert_eq!(
1345            contract.list_uploads(None, None),
1346            [Base58CryptoHash::from([2; 32])]
1347        );
1348        assert_eq!(contract.list_versions(None, None), [&"version".to_owned()]);
1349        assert_eq!(
1350            contract.list_deployments(None, None),
1351            [&Identity::Unrelated.account()]
1352        );
1353        assert_eq!(
1354            contract.get_registry_entry(Identity::Unrelated.account()),
1355            Some(RegistryEntryView::Deployed(deployed.clone()))
1356        );
1357        assert_eq!(
1358            contract.get_deployment(Identity::Unrelated.account()),
1359            Some(&deployed)
1360        );
1361        for (count, offset) in [(Some(0), None), (None, Some(99))] {
1362            assert!(contract.list_versions(count, offset).is_empty());
1363            assert!(contract.list_deployments(count, offset).is_empty());
1364            assert!(contract.list_uploads(count, offset).is_empty());
1365            assert!(contract.list_role(Role::Uploader, offset, count).is_empty());
1366        }
1367    }
1368
1369    #[test]
1370    fn role_set_preserves_other_roles_and_reports_idempotent_updates() {
1371        let mut contract = authorized_contract(Identity::Owner, NearToken::from_yoctonear(1));
1372        contract.set_role(
1373            Identity::Both.account(),
1374            Role::Uploader,
1375            Some(false),
1376            Some(true),
1377        );
1378        assert_eq!(
1379            emitted_events(),
1380            [RegistryEvent::RoleSet {
1381                account_id: Identity::Both.account(),
1382                role: Role::Uploader,
1383                is_granted: false,
1384            }
1385            .to_json()]
1386        );
1387        assert!(!contract.has_role(Identity::Both.account(), Role::Uploader));
1388        assert!(contract.has_role(Identity::Both.account(), Role::Deployer));
1389        testing_env!(VMContextBuilder::new()
1390            .predecessor_account_id(Identity::Owner.account())
1391            .attached_deposit(NearToken::from_yoctonear(1))
1392            .build());
1393        contract.set_role(
1394            Identity::Both.account(),
1395            Role::Uploader,
1396            Some(false),
1397            Some(true),
1398        );
1399        assert_eq!(
1400            emitted_events(),
1401            [RegistryEvent::RoleSet {
1402                account_id: Identity::Both.account(),
1403                role: Role::Uploader,
1404                is_granted: false,
1405            }
1406            .to_json()]
1407        );
1408    }
1409
1410    #[rstest]
1411    #[case::stored(None)]
1412    #[case::global_success(Some(true))]
1413    #[case::global_failure(Some(false))]
1414    fn registration_consumes_matching_upload_only_on_success(#[case] global: Option<bool>) {
1415        let mut contract = contract();
1416        let code = vec![0, 1, 2, 255];
1417        let hash = env::sha256_array(&code);
1418        let payer = env::predecessor_account_id();
1419        stage_upload(&mut contract, payer, code.clone());
1420        next_receipt(Vec::new());
1421        let source = if global.is_some() {
1422            VersionSource::ExistingGlobal(hash.into())
1423        } else {
1424            VersionSource::Stored(code.into())
1425        };
1426        let _ = contract.add_version("new".to_owned(), source);
1427        if let Some(success) = global {
1428            assert!(emitted_events().is_empty());
1429            assert!(contract.get_upload(hash.into()).is_some());
1430            next_receipt(vec![if success {
1431                PromiseResult::Successful(vec![])
1432            } else {
1433                PromiseResult::Failed
1434            }]);
1435            let _ = contract.add_version_01_finalize("new".to_owned());
1436        }
1437        let success = global.unwrap_or(true);
1438        assert_eq!(contract.get_upload(hash.into()).is_none(), success);
1439        assert_eq!(contract.get_version("new".to_owned()).is_some(), success);
1440        assert_eq!(emitted_events().len(), usize::from(success));
1441        assert!(!get_created_receipts().iter().any(|receipt| receipt
1442            .actions
1443            .iter()
1444            .any(|action| matches!(action, MockAction::Transfer { .. }))));
1445    }
1446
1447    #[test]
1448    fn uploaded_approval_moves_bytes_and_retains_removed_key() {
1449        let mut contract = contract();
1450        let code = vec![0, 1, 2, 255];
1451        let hash = env::sha256_array(&code);
1452        let payer = env::predecessor_account_id();
1453        stage_upload(&mut contract, payer, code.clone());
1454        next_receipt(Vec::new());
1455        let _ = contract.approve_version("new".to_owned(), ApprovedCode::Uploaded(hash.into()));
1456        assert_eq!(contract.get_upload(hash.into()), None);
1457        assert_eq!(
1458            contract.get_version_code_chunk("new".to_owned(), 0, 10),
1459            Some(code)
1460        );
1461        let info = VersionInfo {
1462            code_hash: hash.into(),
1463            availability: VersionAvailability::Stored { code_len: 4 },
1464        };
1465        assert_eq!(contract.get_version("new".to_owned()), Some(info));
1466        assert_eq!(
1467            emitted_events(),
1468            [RegistryEvent::VersionAdded {
1469                version_key: "new".to_owned(),
1470                info
1471            }
1472            .to_json()]
1473        );
1474        contract.remove_version("new".to_owned());
1475        assert_eq!(
1476            contract.get_version("new".to_owned()).unwrap().availability,
1477            VersionAvailability::Removed
1478        );
1479        assert!(contract
1480            .list_versions(None, None)
1481            .iter()
1482            .any(|key| key.as_str() == "new"));
1483    }
1484
1485    #[rstest]
1486    #[case(0)]
1487    #[case(4)]
1488    #[case(32_768)]
1489    fn upload_storage_is_locked_and_owner_removal_credits_the_uploader(#[case] code_len: usize) {
1490        let mut contract = authorized_contract(Identity::Uploader, NearToken::ZERO);
1491        let payer = Identity::Uploader.account();
1492        let before = contract.storage_balance_of(payer.clone()).unwrap();
1493        let storage_before = env::storage_usage();
1494        let hash = contract.upload_code(vec![42; code_len]);
1495        let stored_bytes = env::storage_usage() - storage_before;
1496        let cost = env::storage_byte_cost()
1497            .checked_mul(u128::from(stored_bytes))
1498            .unwrap();
1499        let charged = contract.storage_balance_of(payer.clone()).unwrap();
1500        assert_eq!(charged.total, before.total);
1501        assert_eq!(
1502            charged.available,
1503            before.available.checked_sub(cost).unwrap()
1504        );
1505        assert_eq!(
1506            contract.get_upload(hash).unwrap().code_len,
1507            u32::try_from(code_len).unwrap()
1508        );
1509        testing_env!(VMContextBuilder::new()
1510            .storage_usage(env::storage_usage())
1511            .predecessor_account_id(Identity::Owner.account())
1512            .attached_deposit(NearToken::from_yoctonear(1))
1513            .build());
1514        contract.remove_upload(hash);
1515        assert_eq!(contract.storage_balance_of(payer).unwrap(), before);
1516        assert_eq!(env::storage_usage(), storage_before);
1517        assert!(get_created_receipts().is_empty());
1518    }
1519
1520    #[rstest]
1521    #[case::owner(Identity::Owner, true)]
1522    #[case::uploader(Identity::Uploader, false)]
1523    #[case::deployer(Identity::Deployer, true)]
1524    #[case::both(Identity::Both, true)]
1525    #[case::unrelated(Identity::Unrelated, false)]
1526    fn deploy_authority_follows_predecessor(#[case] identity: Identity, #[case] allowed: bool) {
1527        // The fixture sets signer=Owner independently of the selected predecessor.
1528        let mut contract = authorized_contract(identity, NearToken::from_near(1));
1529        contract.versions.insert(
1530            "code".to_owned(),
1531            VersionEntry::Code {
1532                hash: [1; 32],
1533                code: Some(vec![1]),
1534            },
1535        );
1536        let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
1537            contract
1538                .deploy("child".to_owned(), "code".to_owned(), vec![].into(), None)
1539                .detach();
1540        }));
1541        if allowed {
1542            outcome.unwrap();
1543            let child: AccountId = format!("child.{}", env::current_account_id())
1544                .parse()
1545                .unwrap();
1546            assert_eq!(
1547                contract.get_registry_entry(child),
1548                Some(RegistryEntryView::Reserved)
1549            );
1550        } else {
1551            let error = outcome.unwrap_err();
1552            let message = error
1553                .downcast_ref::<String>()
1554                .map(String::as_str)
1555                .or_else(|| error.downcast_ref::<&str>().copied())
1556                .unwrap();
1557            assert!(message.contains("Unauthorized role"), "{message}");
1558            assert!(contract.registry.is_empty());
1559        }
1560    }
1561
1562    #[test]
1563    fn ownership_transfer_preserves_explicit_grants_without_synthetic_membership() {
1564        let mut contract = contract();
1565        let old = contract.own_get_owner().unwrap();
1566        let new: AccountId = "new.near".parse().unwrap();
1567        next_receipt(Vec::new());
1568        contract.set_role(old.clone(), Role::Uploader, Some(true), None);
1569        assert_eq!(
1570            emitted_events(),
1571            [RegistryEvent::RoleSet {
1572                account_id: old.clone(),
1573                role: Role::Uploader,
1574                is_granted: true,
1575            }
1576            .to_json()]
1577        );
1578        next_receipt(Vec::new());
1579        contract.set_role(old.clone(), Role::Uploader, Some(true), None);
1580        contract.set_role(old.clone(), Role::Deployer, Some(true), None);
1581        contract.set_role(old.clone(), Role::Deployer, Some(false), Some(true));
1582        assert!(contract.has_role(old.clone(), Role::Uploader));
1583        assert!(contract.list_role(Role::Deployer, None, None).is_empty());
1584        next_receipt(Vec::new());
1585        contract.set_role(old.clone(), Role::Deployer, Some(false), Some(true));
1586        assert_eq!(
1587            contract.list_role(Role::Uploader, None, None),
1588            [old.clone()]
1589        );
1590        assert!(contract.list_role(Role::Uploader, None, Some(0)).is_empty());
1591        assert!(contract
1592            .list_role(Role::Uploader, Some(10), None)
1593            .is_empty());
1594        contract.own_propose_owner(Some(new.clone()));
1595        contract.own_propose_owner(None);
1596        assert_eq!(contract.own_get_proposed_owner(), None);
1597        contract.own_propose_owner(Some(new.clone()));
1598        testing_env!(VMContextBuilder::new()
1599            .predecessor_account_id(new.clone())
1600            .attached_deposit(NearToken::from_yoctonear(1))
1601            .build());
1602        contract.own_accept_owner();
1603        assert_eq!(contract.own_get_owner(), Some(new.clone()));
1604        assert_eq!(contract.own_get_proposed_owner(), None);
1605        assert!(contract.has_role(old.clone(), Role::Uploader));
1606        assert!(!contract.has_role(old.clone(), Role::Deployer));
1607        assert!(!contract.has_role(new.clone(), Role::Uploader));
1608        assert!(!contract.has_role(new, Role::Deployer));
1609        assert_eq!(contract.list_role(Role::Uploader, None, None), [old]);
1610    }
1611
1612    const STORED: &str = "market@1.5.0";
1613    const REMOVED: &str = "market@1.0.0";
1614    const GLOBAL: &str = "oracle@0.4.1";
1615
1616    fn contract() -> Contract {
1617        testing_env!(VMContextBuilder::new().build());
1618        let mut contract = Contract::new();
1619        let payer = env::predecessor_account_id();
1620        fund_storage(&mut contract, payer);
1621        contract.versions.insert(
1622            STORED.to_string(),
1623            VersionEntry::Code {
1624                hash: [1u8; 32],
1625                code: Some(vec![0xau8; 300]),
1626            },
1627        );
1628        contract.versions.insert(
1629            REMOVED.to_string(),
1630            VersionEntry::Code {
1631                hash: [2u8; 32],
1632                code: None,
1633            },
1634        );
1635        contract
1636            .versions
1637            .insert(GLOBAL.to_string(), VersionEntry::GlobalHash([3u8; 32]));
1638        contract
1639    }
1640
1641    #[rstest]
1642    #[case(STORED, Some(VersionAvailability::Stored { code_len: 300 }))]
1643    #[case(REMOVED, Some(VersionAvailability::Removed))]
1644    #[case(GLOBAL, Some(VersionAvailability::Global))]
1645    #[case("nothing@0.0.0", None)]
1646    fn get_version_separates_all_four_states(
1647        #[case] key: &str,
1648        #[case] expected: Option<VersionAvailability>,
1649    ) {
1650        let info = contract().get_version(key.to_string());
1651        assert_eq!(info.map(|info| info.availability), expected);
1652    }
1653
1654    /// `get_deployment` maps a reserved name to `None`, which reads as "free" — but `deploy`
1655    /// refuses it just as firmly as a deployed one.
1656    #[test]
1657    fn get_registry_entry_reports_reserved_that_get_deployment_hides() {
1658        let mut contract = contract();
1659        let reserved: AccountId = "reserved.registry.near".parse().unwrap();
1660        let deployed: AccountId = "deployed.registry.near".parse().unwrap();
1661        let deployment = Deployment {
1662            version_key: STORED.to_string(),
1663            code_hash: [1u8; 32].into(),
1664            block_height: 1.into(),
1665        };
1666        contract
1667            .registry
1668            .insert(reserved.clone(), RegistryEntry::Reserved);
1669        contract.registry.insert(
1670            deployed.clone(),
1671            RegistryEntry::Deployed(deployment.clone()),
1672        );
1673
1674        assert_eq!(contract.get_deployment(reserved.clone()), None);
1675        assert_eq!(
1676            contract.get_registry_entry(reserved),
1677            Some(RegistryEntryView::Reserved),
1678        );
1679        assert_eq!(
1680            contract.get_registry_entry(deployed),
1681            Some(RegistryEntryView::Deployed(deployment)),
1682        );
1683        assert_eq!(
1684            contract.get_registry_entry("free.registry.near".parse().unwrap()),
1685            None,
1686        );
1687    }
1688
1689    /// A fresh receipt as the owner with one yocto attached, which also clears earlier logs.
1690    fn next_receipt(promise_results: Vec<PromiseResult>) {
1691        testing_env!(
1692            VMContextBuilder::new()
1693                .attached_deposit(NearToken::from_yoctonear(1))
1694                .build(),
1695            near_sdk::test_vm_config(),
1696            near_sdk::RuntimeFeesConfig::test(),
1697            std::collections::HashMap::default(),
1698            promise_results,
1699        );
1700    }
1701
1702    fn emitted_events() -> Vec<serde_json::Value> {
1703        get_logs()
1704            .iter()
1705            .filter_map(|log| log.strip_prefix("EVENT_JSON:"))
1706            .map(|event| serde_json::from_str(event).unwrap())
1707            .collect()
1708    }
1709
1710    fn deployment() -> Deployment {
1711        Deployment {
1712            version_key: STORED.to_string(),
1713            code_hash: [1u8; 32].into(),
1714            block_height: 1.into(),
1715        }
1716    }
1717
1718    #[test]
1719    fn adding_stored_code_emits_version_added() {
1720        let mut contract = contract();
1721        next_receipt(Vec::new());
1722        let code = vec![0xbbu8; 10];
1723
1724        let _ = contract.add_version(
1725            "new@1.0.0".to_string(),
1726            VersionSource::Stored(Base64VecU8(code.clone())),
1727        );
1728
1729        let expected = RegistryEvent::VersionAdded {
1730            version_key: "new@1.0.0".to_string(),
1731            info: VersionInfo {
1732                code_hash: env::sha256_array(&code).into(),
1733                availability: VersionAvailability::Stored { code_len: 10 },
1734            },
1735        };
1736        assert_eq!(emitted_events(), vec![expected.to_json()]);
1737    }
1738
1739    /// A global version is announced only once the publish or probe receipt succeeded; a failed one
1740    /// is rolled back without ever having been visible.
1741    #[rstest]
1742    #[case::confirmed(PromiseResult::Successful(Vec::new()), true)]
1743    #[case::rolled_back(PromiseResult::Failed, false)]
1744    fn add_version_finalize_emits_only_on_success(
1745        #[case] result: PromiseResult,
1746        #[case] added: bool,
1747    ) {
1748        let mut contract = contract();
1749        next_receipt(vec![result]);
1750
1751        let _ = contract.add_version_01_finalize(GLOBAL.to_string());
1752
1753        let expected = RegistryEvent::VersionAdded {
1754            version_key: GLOBAL.to_string(),
1755            info: VersionInfo {
1756                code_hash: [3u8; 32].into(),
1757                availability: VersionAvailability::Global,
1758            },
1759        };
1760        assert_eq!(
1761            emitted_events(),
1762            if added {
1763                vec![expected.to_json()]
1764            } else {
1765                Vec::new()
1766            },
1767        );
1768        assert_eq!(contract.get_version(GLOBAL.to_string()).is_some(), added);
1769    }
1770
1771    /// Only a removal that clears code is announced: repeating one, or naming an unknown key,
1772    /// changes nothing.
1773    #[rstest]
1774    #[case::stored(STORED, true)]
1775    #[case::already_removed(REMOVED, false)]
1776    #[case::unknown("nothing@0.0.0", false)]
1777    fn remove_version_emits_only_when_it_clears_code(#[case] key: &str, #[case] removed: bool) {
1778        let mut contract = contract();
1779        next_receipt(Vec::new());
1780
1781        contract.remove_version(key.to_string());
1782
1783        let expected = RegistryEvent::VersionRemoved {
1784            version_key: key.to_string(),
1785            code_hash: [1u8; 32].into(),
1786        };
1787        assert_eq!(
1788            emitted_events(),
1789            if removed {
1790                vec![expected.to_json()]
1791            } else {
1792                Vec::new()
1793            },
1794        );
1795    }
1796
1797    #[rstest]
1798    #[case::initialized(PromiseResult::Successful(Vec::new()), true)]
1799    #[case::released(PromiseResult::Failed, false)]
1800    fn deploy_finalize_emits_only_on_success(
1801        #[case] result: PromiseResult,
1802        #[case] deployed: bool,
1803    ) {
1804        let mut contract = contract();
1805        let account_id: AccountId = "one.registry.near".parse().unwrap();
1806        contract
1807            .registry
1808            .insert(account_id.clone(), RegistryEntry::Reserved);
1809        next_receipt(vec![result]);
1810
1811        let _ =
1812            contract.deploy_01_finalize(Some(account_id.clone()), None, deployment(), None, None);
1813
1814        let expected = RegistryEvent::Deployed {
1815            account_id: account_id.clone(),
1816            deployment: deployment(),
1817            deployer: None,
1818            full_access_keys: None,
1819        };
1820        assert_eq!(
1821            emitted_events(),
1822            if deployed {
1823                vec![expected.to_json()]
1824            } else {
1825                Vec::new()
1826            },
1827        );
1828        assert_eq!(
1829            contract.get_registry_entry(account_id),
1830            deployed.then(|| RegistryEntryView::Deployed(deployment())),
1831        );
1832    }
1833
1834    #[test]
1835    #[should_panic(expected = "Missing deployment account ID")]
1836    fn finalize_needs_the_account_under_either_name() {
1837        let _ = contract().deploy_01_finalize(
1838            None,
1839            None,
1840            Deployment {
1841                version_key: STORED.to_string(),
1842                code_hash: [1u8; 32].into(),
1843                block_height: 1.into(),
1844            },
1845            None,
1846            None,
1847        );
1848    }
1849
1850    #[rstest]
1851    #[case::whole(0, 300, 300)]
1852    #[case::prefix(0, 10, 10)]
1853    #[case::tail(290, 64, 10)]
1854    #[case::past_the_end_reads_empty(300, 64, 0)]
1855    #[case::far_past_the_end_reads_empty(9_999, 64, 0)]
1856    fn code_chunk_clamps_to_the_blob(
1857        #[case] offset: u32,
1858        #[case] len: u32,
1859        #[case] expected: usize,
1860    ) {
1861        let chunk = contract()
1862            .get_version_code_chunk(STORED.to_string(), offset, len)
1863            .expect("a stored version yields bytes");
1864        assert_eq!(chunk.len(), expected);
1865        assert!(chunk.iter().all(|byte| *byte == 0xau8));
1866    }
1867
1868    /// Reassembly is the point: chunks concatenated in order must equal the stored blob.
1869    #[test]
1870    fn code_chunks_reassemble_exactly() {
1871        let contract = contract();
1872        let mut reassembled = Vec::new();
1873        let mut offset = 0;
1874        loop {
1875            let chunk = contract
1876                .get_version_code_chunk(STORED.to_string(), offset, 128)
1877                .expect("a stored version yields bytes");
1878            if chunk.is_empty() {
1879                break;
1880            }
1881            offset += u32::try_from(chunk.len()).unwrap();
1882            reassembled.extend(chunk);
1883        }
1884        assert_eq!(reassembled, vec![0xau8; 300]);
1885    }
1886
1887    /// Neither a global version nor one whose code was removed has bytes to read, so the caller
1888    /// has to resolve those by hash instead.
1889    #[rstest]
1890    #[case(GLOBAL)]
1891    #[case(REMOVED)]
1892    #[case("nothing@0.0.0")]
1893    fn code_chunk_is_absent_without_stored_code(#[case] key: &str) {
1894        assert_eq!(
1895            contract().get_version_code_chunk(key.to_string(), 0, 64),
1896            None,
1897        );
1898    }
1899
1900    #[test]
1901    #[should_panic(expected = "len exceeds maximum")]
1902    fn code_chunk_refuses_an_oversized_read() {
1903        contract().get_version_code_chunk(STORED.to_string(), 0, Contract::MAX_CODE_CHUNK_LEN + 1);
1904    }
1905
1906    #[test]
1907    #[should_panic(expected = "Upgrade code must not be empty")]
1908    fn upgrade_refuses_an_empty_blob() {
1909        testing_env!(VMContextBuilder::new()
1910            .current_account_id("registry.near".parse().unwrap())
1911            .predecessor_account_id("registry.near".parse().unwrap())
1912            .attached_deposit(NearToken::from_yoctonear(1))
1913            .build());
1914        let mut contract = Contract::new();
1915        contract
1916            .upgrade(
1917                UpgradeSource::Code(Base64VecU8(Vec::new())),
1918                Base64VecU8(Vec::new()),
1919            )
1920            .detach();
1921    }
1922}
1923
1924#[cfg(target_arch = "wasm32")]
1925mod custom_getrandom {
1926    #![allow(clippy::no_mangle_with_rust_abi)]
1927
1928    use getrandom::{register_custom_getrandom, Error};
1929    use near_sdk::env;
1930
1931    register_custom_getrandom!(custom_getrandom);
1932
1933    #[allow(clippy::unnecessary_wraps)]
1934    pub fn custom_getrandom(buf: &mut [u8]) -> Result<(), Error> {
1935        buf.copy_from_slice(&env::random_seed_array());
1936        Ok(())
1937    }
1938}