SAVITRI-1155 : Standard de Jeton Multi-Actifs

SAVITRI-1155 (SMA -- Savitri Multi Asset) est le standard de jeton multi-actifs pour le Savitri Network, équivalent à l'ERC-1155 d'Ethereum. Il prend en charge les jetons fongibles et non fongibles dans un seul contrat avec des opérations par lot efficaces.

Interface

Fonction	Paramètres	Retourne	Description
balance_of	owner, id	u128	Solde d'un jeton spécifique pour un propriétaire
balance_of_batch	owners[], ids[]	u128[]	Requête de solde par lot
safe_transfer_from	from, to, id, amount, data	Result	Transférer des jetons
safe_batch_transfer_from	from, to, ids[], amounts[], data	Result	Transfert par lot
set_approval_for_all	operator, approved	Result	Approuver un opérateur pour tous les jetons
is_approved_for_all	owner, operator	bool	Vérifier l'approbation de l'opérateur

Disposition du Stockage

Stockage des Soldes (Emplacement 100+)

Mappage imbriqué : balances[owner][id]

hash1 = keccak256(owner || 100)
hash2 = keccak256(id || hash1)
slot  = first 8 bytes of hash2 as u64

Stockage des Approbations d'Opérateur (Emplacement 200+)

Mappage imbriqué : operator_approvals[owner][operator]

hash1 = keccak256(owner || 200)
hash2 = keccak256(operator || hash1)
slot  = first 8 bytes of hash2 as u64

Cette disposition offre :

• Distribution uniforme : Keccak256 assure une distribution uniforme des emplacements
• Absence de collisions : Probabilité de collision négligeable
• Requêtes par lot efficaces : Chaque emplacement est calculé indépendamment
• Affinité de cache : ContractStorage met en cache les lectures

Utilisation

Transfert Unique

use savitri_contracts::contracts::standards::savitri1155::SAVITRI1155;

SAVITRI1155::safe_transfer_from(
    &mut contract_storage,
    &storage,
    &from,          // [u8; 32]
    &to,            // [u8; 32]
    1,              // token id
    100,            // amount
    &[],            // data
    &mut event_system,
    Some(&mut gas_meter),
)?;

Transfert par Lot

SAVITRI1155::safe_batch_transfer_from(
    &mut contract_storage,
    &storage,
    &from,
    &to,
    &[1, 2, 3],           // token ids
    &[100, 50, 1],        // amounts
    &[],                   // data
    &mut event_system,
    Some(&mut gas_meter),
)?;

Requête de Solde par Lot

let balances = SAVITRI1155::balance_of_batch(
    &contract_storage,
    &storage,
    &[owner1, owner2, owner3],
    &[token_id_1, token_id_2, token_id_3],
)?;

Approbation d'Opérateur

// Approve an operator for all tokens
SAVITRI1155::set_approval_for_all(
    &mut contract_storage,
    &storage,
    &owner,
    &operator,
    true,           // approved
    &mut event_system,
    Some(&mut gas_meter),
)?;

// Check approval
let approved = SAVITRI1155::is_approved_for_all(
    &contract_storage,
    &storage,
    &owner,
    &operator,
)?;

Événements

Événement	Champs	Description
TransferSingle	operator, from, to, id, amount	Transfert de jeton unique
TransferBatch	operator, from, to, ids[], amounts[]	Transfert par lot
ApprovalForAll	owner, operator, approved	Approbation d'opérateur modifiée

Cas d'Usage

Scénario	Type de Jeton	Exemple
Monnaie en jeu	Fongible (id=1)	1000 pièces d'or
Objets uniques	Non fongible (amount=1)	Épée légendaire #42
Semi-fongible	Offre limitée	50 copies d'une carte rare
Récompenses	Fongible	Jetons de récompense PoU
Certificats	Non fongible	Certification de validateur

Optimisation par Lot

L'implémentation SAVITRI-1155 optimise les opérations par lot en :

1. Pré-calculant tous les emplacements avant la lecture du stockage
2. Exploitant le cache de ContractStorage pour éviter les lectures répétées en base de données
3. Calculant les emplacements indépendamment pour permettre de futures lectures parallèles
4. Minimisant le décodage d'adresses en réutilisant les adresses décodées entre les opérations