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 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 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 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 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
140impl_versioned_state!(Contract, State, crate::state::Migration);
143
144impl 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 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 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 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 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 #[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 #[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 #[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 pub fn get_version(&self, version_key: String) -> Option<VersionInfo> {
358 self.versions.get(&version_key).map(VersionEntry::info)
359 }
360
361 pub fn get_registry_entry(&self, account_id: AccountId) -> Option<RegistryEntryView> {
366 self.registry.get(&account_id).map(RegistryEntry::view)
367 }
368
369 #[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 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 #[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 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 VersionSource::ExistingGlobal(hash) => {
560 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 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 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(¤t_account_id),
663 "Deployment account cannot be created",
664 );
665
666 require!(
667 !state.registry.contains_key(&account_id),
668 "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 market_id: Option<AccountId>,
755 deployment: Deployment,
756 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 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 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 #[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 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 #[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 #[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 #[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 #[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}