Mécanisme de garantie de stockage pour conflux

Conflux Chinese community 2022-01-14 22:53:28

Fiche d'information

Il y a eu récemment de petits partenaires de la communauté qui développent des contrats intelligents et les déploient dansConfluxLe réseau a rencontré une partie de l'hypothèque lors de l'envoi d'interactions à des contrats intelligentscfx,Et retourner une partie après l'interactioncfxDeQuestions.

Comme le rôti a répondu,Dans le blockchain en raison de la nécessité de facturer un certain montant de dépôt de stockage en fonction de l'occupation de l'espace contractuel intelligent par l'appelant,Ce coût est généralement supérieur aux besoins réels,Quand l'espace sera libéré,Il retournera à l'opérateur un certain nombre deGASDépenses.

ConfluxDansSpécification du Protocole Ce mécanisme est décrit en détail dans l'enseignement secondaire technique. (Voir par.28(En milliers de dollars des États - Unis)).

Introduction à la théorie

InConfluxIntroduit dansCollateral for storage(AbréviationsCFS)Mécanismes, Comme méthode de tarification pour l'utilisation du stockage ,Comparé àEthereum Frais de stockage uniques en ,CFS Le mécanisme serait plus juste et plus équitable .En principe, Un tel mécanisme nécessite le verrouillage d'une somme d'argent , En garantie de l'espace de stockage . Avant que l'espace de stockage approprié ne soit libéré ou écrasé par d'autres , Les garanties seront verrouillées , Et l'intérêt correspondant sur la garantie verrouillée sera directement distribué aux mineurs , Pour l'entretien des espaces de stockage .Donc,,Conflux Le coût de stockage dépend également de la durée d'occupation de l'espace .

InConfluxDans le réseau, L'espace occupé par chaque entrée de stockage est 64B(BPourBytes,Octets), C'est aussi la clé de l'état du monde / Taille de la paire de valeurs , Il est à noter que les clés sont généralement 256bitsLong,La valeur est aussi256bitsLong( Chacun est 32BLong,Ensemble pour64BLong). Dépôt requis pour le stockage et capable de couvrir tous les articles stockés 64B Le plus petit multiple de . Pour chaque entrée stockée , Le dernier compte écrit à l'entrée est appelé le propriétaire de l'entrée de stockage . Si une entrée de stockage exécute un contrat CC'est écrit, Et le garant fournit la garantie ,AlorsC Considéré comme l'auteur de cet article , Devenir propriétaire en conséquence (Voir détails7.1Section). Dans le monde , Tout au long du cycle de vie d'une entrée de stockage , Le propriétaire de cette entrée doit verrouiller un nombre fixe de CFX Dépôt de stockage en tant qu'espace de stockage occupé .Plus précisément,, Chaque taille est 64B Entrée de stockage pour , Son propriétaire sera verrouillé. 1/16CFX. Et l'occupation 1KB L'espace paie 1CFX Comme caution , La formule correspondante est la suivante: :

( 1024 64 ) × ( 1 16 ) = 1 C F X \left(\frac{1024}{64}\right)×\left(\frac{1}{16}\right)=1(CFX)

Sur le compte α Lorsque vous devenez propriétaire d'une entrée de stockage ( Qu'il s'agisse de créer ou de modifier ),α Cette entrée doit être verrouillée immédiatement 1/16 CFX.Siα Il y a assez d'équilibre , Le dépôt requis sera automatiquement verrouillé ,Sinon, siα Solde insuffisant ,L'opération échouera,α Impossible de créer ou de modifier l'entrée .

Lorsqu'une entrée de stockage est supprimée de l'état du monde ,Correspondant1/16 CFX Le dépôt sera débloqué et retourné au solde du propriétaire de l'entrée . Si la propriété d'une entrée de stockage change , De l'ancien propriétaire 1/16 CFX Le dépôt est débloqué , Et le nouveau propriétaire doit être verrouillé en même temps 1/16 CFX Comme caution .

Pour plus de commodité,Conflux Fonction introduite dans CFS, Il aura une adresse de compte α Et un état du monde σComme entrée,Et revenir à Dans l'état du monde σEn bas.,Comptesα Total des dépôts de verrouillage stockés . Si l'état du monde σ Clair dans le contexte ,Par souci de concision,Nous utilisonsCFS(α)RemplacerCFS(α;σ),La formule est la suivante::

C F S ( α ) C F S ( α ; σ ) Comptes a Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous × ( 1 16 ) C F X CFS(α)≡CFS(α;σ)≡Comptesa Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous ×\left(\frac{1}{16}\right)(CFX)

Spécial,Pour unα=S(T) Transaction envoyée T(Ouα=TαSiT L'adresse est appelée Tα Contrat de parrainage ),OrdreσPourT L'état du monde avant et après l'exécution ,σ' Est l'état du monde après l'exécution de la transaction ,PourLimites de stockageChampTlIl y a unCFS(α;σ)≤CFS(α;σ)+Tl/1018Affirmation de.

Points clés: J'essaie de comprendre ce qui appelle un gage contractuel. CFXCombien?, Assurez - vous de comprendre le nombre d'entrées de variables dans le contrat , Et combien d'entrées ont été modifiées lors de l'opération via le contrat d'appel de fonction , Et le nombre de changements est enregistré dans le blockchain !

SolidityMécanisme de gestion de la mémoire

SelonSolidity Pour les documents gérés en mémoire DescriptionEtConflux Mécanisme de dépôt ,Nous pouvons découvrir, Stockage contractuel requis keyEtvalueEffectuer l'entretien,En général:keyLa longueur de256bits,value La longueur de 256bits, L'espace de stockage par contrat intelligent est organisé comme suit: ,Parmi eux{0,1}256Représentation256Chaîne de bits( Il n'y a que 0Ou1Deux valeurs),Chaquekey/value Oui peut être interprété comme une entrée

Entrée Clé/Adresse({0,1}256) Valeur({0,1}256)
1 0...00000 0
2 0...00001 1
3 0...00002 2
... ... ...
2256 f...fffff 0

Parce que256bits=32bytes,Deux.256bits La longueur correspondante est : 32 + 32 = 64 B y t e s 32+32=64(Bytes)

Solidity Les variables communes et le nombre d'entrées correspondantes

Variables Longueur Mode de définition
Variables générales 1 Les variables normales correspondent 1Entrées uint public count=0;
mapping mappingDe1- Oui.keyTout correspond à1Entrées mapping(address => uint) public balances;
array Tableau pour chaque 1 Éléments correspondant à 1Entrées,Chef d & apos; équipearr.length C'est extra 1Entrées uint[5] fixedArr = [1,2,3,4,5]; string productname;
struct structChaquefield Somme des entrées correspondantes struct Person {uint age;uint stuID;string name;}

Conflux Description du mécanisme de dépôt pour

In Conflux Dans le réseau, Les frais de stockage des dépôts sont pour chaque 1024 Octets 1 CFX. Comme chaque entrée occupe 64 Octets,Donc,, Les frais de dépôt par article sont les suivants: 1/16 CFX. Pendant l'exécution de chaque transaction , Les frais de dépôt nouvellement engagés seront facturés uniformément à la fin de l'exécution de la transaction. . Si une entrée de stockage a été écrasée par quelqu'un d'autre , La personne qui réécrit paiera le dépôt de stockage , Et le déposant initial recevra le dépôt retourné .Il convient de mentionner que, Le remboursement de la caution est “Silence” Ajouté au solde , Aucune transaction de transfert disponible .

Conflux Pour chaque transaction , Une limite supérieure de stockage est requise (En octets). La limite supérieure fixe , Le déposant du dépôt ne doit pas dépasser la limite de stockage multipliée par 1/1024 CFX. Si cette valeur est trop basse , Le dépôt après exécution dépassera le plafond ,Échec de l'exécution. Si le remplissage est trop élevé , Le solde de l'expéditeur est insuffisant pour payer le dépôt ,Peut également entraîner l'échec de la transaction.

Contrat de déploiement

VoirLiens, Essayer de déployer et d'invoquer des contrats intelligents .

Exemple d'explication

1. Un contenant1OrdinaireuintExemples de variables

Le Code du contrat intelligent est le suivant :

pragma solidity ^0.5.0;
contract Counter {
uint public count=0;
event SelfEvent(address indexed sender, uint current);
constructor() public {
}
function inc(uint num) public returns (uint){
return count += num;
}
function self() public {
emit SelfEvent(msg.sender, count);
}
}
Copier le Code

Parce que seul le contrat intelligent uint public count=0; Une variable, Ça ne correspond qu'à 1Entrées, Analyse selon la formule précédente : C F S ( α ) C F S ( α ; σ ) Comptes a Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous × ( 1 16 ) C F X CFS(α)≡CFS(α;σ)≡Comptesa Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous ×\left(\frac{1}{16}\right)(CFX)

C'est précisément parce que uint public count=0 La variable correspond exactement à un 64BEntrée pour, En combinaison avec l'exemple que nous avons donné précédemment , Le montant réel du gage est: :0.0625 CFX ( 1 16 ) = 0.0625 C F X \left(\frac{1}{16}\right)=0.0625(CFX)

Ceci est vérifié par rapport à l'appel réel au contrat : Les cas où le Code du contrat est invoqué sont les suivants: (Nom du fichier:call_calc.js):

const { Conflux, util } = require('js-conflux-sdk');
// Cette adresse est imprimée dessus. receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x845dd6f64bb3d2771a8f30dc85bb14f5ac26b75e';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425********************';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812********************';
const compiled = require(`./build/Counter.json`)
async function main() {
const cfx = new Conflux({
url: 'http://main.confluxrpc.org',
});
const contract = cfx.Contract({
address : contractAddress,
abi: compiled.abi,
});
const before_call_balance = await cfx.getBalance(public_address);
console.log("before account1 call the current drip:"+before_call_balance.toString());
console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
let inc = await contract.inc(10);
console.log("Produits:" + inc.toString());
const account1 = cfx.Account(PRIVATE_KEY1);// Créer un compte avec une clé privée 
// Enregistrer et dépenser CFX
await contract.inc(10).sendTransaction({ from: account1 }).confirmed();
const after_call_balance = await cfx.getBalance(public_address);
console.log("after account1 call inc(10) the current drip:"+after_call_balance.toString());
console.log("after account1 call inc(10) the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
//Créationaccount2, Et essayez d'appeler le contrat pour le libérer. account1Decfx
const account2 = cfx.Account(PRIVATE_KEY2);// Créer un compte avec une clé privée 
const before_account2_call_balance = await cfx.getBalance(public_address);
console.log("before account2 call inc(5) the current drip:"+after_call_balance.toString());
console.log("before account2 call inc(5) the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
await contract.inc(5).sendTransaction({ from: account2 }).confirmed();
const after_account2_call_balance = await cfx.getBalance(public_address);
console.log("after account2 call inc(10) the current drip:"+after_account2_call_balance.toString());
console.log("after account2 call inc(10) the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));
Copier le Code

Appelé par:

node call_calc.js
Copier le Code

Pour faciliter la description, Utiliser le compte participant au contrat d'appel account1Etaccount2Représentation, Contrat invoqué contractReprésentation, Résumer ses informations de compte et son adresse de compte correspondante , Les tableaux suivants sont présentés: :

Nom du compte Adresse du compte
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x845dd6f64bb3d2771a8f30dc85bb14f5ac26b75e

Pour plus de commodité, Ensuite, utilisez le nom du compte dans le tableau ci - dessus pour désigner chaque compte.

Avant d'appeler,UtiliserconfluxscanRegarde.account1CorrespondantCFXSolde, Le solde trouvé est :1994.680912261955354268 CFX.

confluxscan1

(1)Utiliseraccount1 Faire le premier appel contractuel :

call

Parce queaccount1 Le contrat d'appel prend de l'espace ,Il faut le remettre.CFX Comme caution

Après le démarrage du programme:Afficher d'abordaccount1Solde du compte:1994.680912261955383167 CFX.

Le programme utiliseraaccount1Appelezcontract.inc(10) Initier une interaction avec le contrat , Trouvé une fois l'appel terminé account1 Le solde du compte pour :1994.618412261955356217 CFX.

sub_call1

C'est - à - dire passer account1Avec contratcontract Cette interaction , Son compte a été déduit : 1994.680912261955383167 1994.618412261955356217 = 0.06250000000002695 C F X 1994.680912261955383167-1994.618412261955356217=0.06250000000002695(CFX)

Cela signifie qu'en raison de l'appel contract.inc(10)Interaction avec le contrat.account1 C'est fait 0.06250000000002695DeCFX.

Utiliseraccount2Contrat d'appel,Pour aideraccount1Libérer de l'espace

Le programme continuera à fonctionner,Et utiliseraccount2Par appelcontract.inc(5) Initier une interaction avec le contrat

Avant d'appeler,account1 Le solde du compte pour :1994.618412261955356217 CFX,Et étapes(1)Finaccount1 Le solde du compte de .

account2 Après avoir appelé le contrat ,account1DeCFX Le solde devient 1994.680912261955356217 CFX

sub_call2

C'est - à - dire,Passe.account2 Après l'appel au contrat ,account1CompteCFX Variation du solde à : 1994.618412261955356217 1994.680912261955356217 = 0.0625 C F X 1994.618412261955356217-1994.680912261955356217=-0.0625(CFX)

Cela signifie,Parce queaccount1Occupé64Bytes Espace contractuel libéré ,0.0625 CFX Sera retourné à account1Dans le compte de.Suivez les étapes(1) Paiements calculés en :0.06250000000002695 CFX, Nous pouvons spéculer ,account1Appelezcontract.inc(10) Le coût réel est de : 0.06250000000002695 0.0625 = 0.00000000000002695 C F X 0.06250000000002695-0.0625=0.00000000000002695(CFX)

Avant d'invoquer le contrat , Le programme montre account1DeCFXLe solde est:1994.618412261955437067 CFX.

Et après avoir appelé le contrat , Pour le compte correspondant CFXLe solde est:1994.618412261955410117 CFX.

C'est - à - dire qu'après cette interaction avec le contrat, , Le compte a été déduit 0.00000000000002695- Oui.CFX,La formule de calcul est la suivante:: 1994.618412261955437067 1994.618412261955410117 = 0.00000000000002695 C F X 1994.618412261955437067-1994.618412261955410117=0.00000000000002695(CFX)

C'est une preuve indirecte ,account1 L'espace contractuel utilisé pour le stockage des données est 1- Oui.64Bytes: 0.0625 × 16 = 1 (- Oui.) 0.0625×16=1(- Oui.)

On y retourne.confluxscan Voir le compte à account1 Le solde correspondant est: :1994.680912261955327318 CFX confluxscan2 Selon la formule de calcul: 1994.680912261955354268 1994.680912261955327318 = 0.00000000000002695 ( C F X ) 1994.680912261955354268-1994.680912261955327318=0.00000000000002695 (CFX) Ça prouve aussi :account1Appelezcontract.inc(10) En interaction avec le contrat , Son compte a effectivement consommé 0.00000000000002695 CFX

2. Un contenant1Longueur de5( Et modifié au moment de l'appel 5Valeurs des éléments) Exemple de tableau de longueur fixe pour

Le Code du contrat est le suivant::

pragma solidity ^0.5.0;
contract Test {
uint[5] arr = [1,2,3,4,5];
event SelfEvent(address indexed sender, uint[5] current,uint length);
function init() public{
arr[0] = 100;
arr[1] = 200;
}
function getArrayContent() public returns(uint[5] memory){
return arr;
}
function getArrayLength() public returns(uint){
return arr.length;
}
function increment (uint data) public{
for(uint i=0;i<arr.length;i++){
arr[i]+=data;
}
}
function getGrade() public returns (uint){
uint grade = 0 ;
for(uint i=0;i<arr.length;i++){
grade += arr[i];
}
return grade;
}
function self() public {
emit SelfEvent(msg.sender, arr,arr.length);
}
}
Copier le Code

Parce que seul le contrat intelligent uint [] arr = [1,2,3,4,5]; Cette longueur est5Tableau de, Les données du tableau correspondent à 5Entrées,Longueur du tableau5 Ça correspond aussi. 1Entrées,Total6Entrées, Parce que le contrat d'appel increment() La fonction modifie chaque élément du tableau , Mais la longueur du tableau n'a pas changé , Par conséquent, l'analyse est effectuée selon la formule précédente. : C F S ( α ) C F S ( α ; σ ) Comptes a Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous × ( 1 16 ) C F X CFS(α)≡CFS(α;σ)≡Comptesa Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous ×\left(\frac{1}{16}\right)(CFX)

C'est précisément parce que uint [] arr = [1,2,3,4,5]; Les éléments du tableau correspondent exactement à la longueur du tableau 6- Oui.64B Longueur de l'entrée , Mais comme la longueur du tableau n'a pas changé, elle a été écrite à blockchain , En combinaison avec les exemples que nous avons donnés précédemment , Le montant du gage est: :0.3125 CFX ( 1 16 ) × 5 = 0.3125 C F X \left(\frac{1}{16}\right)×5=0.3125(CFX)

Le Code du contrat d'appel est le suivant: :

const { Conflux, util } = require('js-conflux-sdk');
// Cette adresse est imprimée dessus. receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x822ebe7eb36cdf159d6d544f6321e1a5c6619dc2';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425*';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812*';
const compiled = require(`./build/Test.json`)
async function main() {
const cfx = new Conflux({
url: 'http://main.confluxrpc.org',
});
const contract = cfx.Contract({
address : contractAddress,
abi: compiled.abi,
});
let inc = await contract.getGrade();
console.log("output:" + inc.toString());
const before_call_balance = await cfx.getBalance(public_address);
console.log("before account1 call the current drip:"+before_call_balance.toString());
console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
const account1 = cfx.Account(PRIVATE_KEY1);// Créer un compte avec une clé privée 
// Enregistrer et dépenser CFX
await contract.increment(1).sendTransaction({ from: account1 }).confirmed();
const after_call_balance = await cfx.getBalance(public_address);
console.log("after account1 call increment() the current drip:"+after_call_balance.toString());
console.log("after account1 call increment() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
//Créationaccount2, Et essayez d'appeler le contrat pour le libérer. account1Decfx
const account2 = cfx.Account(PRIVATE_KEY2);// Créer un compte avec une clé privée 
const before_account2_call_balance = await cfx.getBalance(public_address);
console.log("before account2 call increment() the current drip:"+after_call_balance.toString());
console.log("before account2 call increment() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
await contract.increment(2).sendTransaction({ from: account2 }).confirmed();
const after_account2_call_balance = await cfx.getBalance(public_address);
console.log("after account2 call increment() the current drip:"+after_account2_call_balance.toString());
console.log("after account2 call increment() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));
Copier le Code

Pour faciliter la description, Utiliser le compte participant au contrat d'appel account1Etaccount2Représentation, Contrat invoqué contractReprésentation, Résumer ses informations de compte et son adresse de compte correspondante , Les tableaux suivants sont présentés: :

Nom du compte Adresse du compte
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x822ebe7eb36cdf159d6d544f6321e1a5c6619dc2

Pour plus de commodité, Ensuite, utilisez le nom du compte dans le tableau ci - dessus pour désigner chaque compte.

Avant d'appeler,UtiliserconfluxscanRegarde.account1CorrespondantCFXSolde, Le solde trouvé est :1986.673099761952452902 CFX.

sample2_scan1

(1)Utiliseraccount1 Faire le premier appel contractuel :

Parce queaccount1Appeléincrement() La fonction modifie l'espace de stockage des enregistrements stockés dans le contrat , Et les données modifiées sont enregistrées par blockchain , C'est pour ça qu'il faut le remettre. CFX Comme caution

Après le démarrage du programme:Afficher d'abordaccount1Solde du compte:1986.673099761952481801 CFX.

Le programme utiliseraaccount1Appelezcontract.increment(1) Initier une interaction avec le contrat , Cette fonction ajoute chaque élément du tableau 1Fonctionnement, Trouvé une fois l'appel terminé account1 Le solde du compte pour :1986.360599761952433413 CFX.

sample2_sub_call1

C'est - à - dire passer account1Avec contratcontract Cette interaction , Son compte a été déduit : 1986.673099761952481801 1986.360599761952433413 = 0.312500000000048388 C F X 1986.673099761952481801-1986.360599761952433413=0.312500000000048388(CFX)

Cela signifie qu'en appelant contract.increment(1) Interagir avec le contrat pour modifier les données et écrire des journaux dans blockchain .account1 C'est fait 0.312500000000048388DeCFX.

Utiliseraccount2Contrat d'appel,Pour aideraccount1Libérer de l'espace

Le programme continuera à fonctionner,Et utiliseraccount2Par appelcontract.increment(2) Initier une interaction avec le contrat

Avant d'appeler,account1 Le solde du compte pour :1986.360599761952433413 CFX, À la fin de l'opération précédente account1 Le solde du compte de .

account2 Après avoir appelé le contrat ,account1DeCFX Le solde devient 1986.673099761952433413 CFX

sub_call2

C'est - à - dire,Passe.account2 Après l'appel au contrat ,account1CompteCFX Variation du solde à : 1986.360599761952433413 1986.673099761952433413 = 0.3125 C F X 1986.360599761952433413-1986.673099761952433413=-0.3125(CFX)

Cela signifie,Parce queaccount1Appelezincrement Fonction modifiée et occupée 320Bytes Taille de l'espace contractuel libéré ,0.3125 CFX Sera retourné à account1Dans le compte de.Suivez les étapes(1) Paiements calculés en :0.06250000000002695 CFX, Nous pouvons spéculer ,account1Appelezcontract.increment(1) Le coût réel est de : 0.312500000000048388 0.3125 = 0.000000000000048388 C F X 0.312500000000048388-0.3125=0.000000000000048388(CFX)

En cours de programmationaccount1 Avant d'invoquer le contrat , Le programme montre account1DeCFXLe solde est:1986.673099761952481801 CFX.

En cours de programmationaccount2 Après avoir appelé le contrat ,account1ComptesCFXLe solde est:1986.673099761952433413 CFX.

C'est - à - dire qu'après cette interaction avec le contrat, ,account1 Le compte a été déduit 0.000000000000048388- Oui.CFX,La formule de calcul est la suivante:: 1986.673099761952481801 1986.673099761952433413 = 0.000000000000048388 C F X 1986.673099761952481801-1986.673099761952433413=0.000000000000048388(CFX)

On y retourne.confluxscan Voir le compte à account1 Le solde correspondant est: :1986.673099761952404514 CFX confluxscan2 w=559&h=159&f=png&s=23450)

Selon la formule de calcul: 1986.673099761952452902 1986.673099761952404514 = 0.000000000000048388 ( C F X ) 1986.673099761952452902-1986.673099761952404514=0.000000000000048388 (CFX) Ça prouve aussi :account1Appelezcontract.incement(1) En interaction avec le contrat , Son compte a effectivement consommé 0.000000000000048388 CFX

3. Un contenu string Et uint ( Et modifié au moment de l'appel uint)DestructExemple

Le Code du contrat est le suivant::

pragma solidity ^0.5.0;
contract Struct_test {
struct Animal {
string name;
uint age;
}
event SelfEvent(address indexed sender,uint current);
event SelfEvent_string(address indexed sender,string current);
Animal animal1 = Animal("Anglais court",5);
Animal animal2 = Animal("Mei - short",5);
function getAnimal(uint inc) public{
animal1.age+=inc;
animal2.age-=inc;
}
function get() public view returns(uint256){
return animal1.age;
}
function self() public {
emit SelfEvent(msg.sender, animal1.age);
emit SelfEvent(msg.sender, animal2.age);
emit SelfEvent_string(msg.sender, animal1.name);
emit SelfEvent_string(msg.sender, animal2.name);
}
}
Copier le Code

Parce qu'un de ces contrats intelligents contient string name; Et uint age; Variable de structure pour Animal ,Parmi euxstring Tableau de longueur variable correspondant , Le nombre d'entrées correspondant est soumis au contenu réel. ,EtuintCorrespond à1Entrées. Appelé dans le contrat getAnimal() La fonction modifie l'Instanciation animal1Etanimal2DeageVariables, Le nombre d'entrées modifiées est 2, Par conséquent, l'analyse est effectuée selon la formule précédente. : C F S ( α ) C F S ( α ; σ ) Comptes a Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous × ( 1 16 ) C F X CFS(α)≡CFS(α;σ)≡Comptesa Dans l'état du monde σ Nombre total d'entrées de stockage détenues sous ×\left(\frac{1}{16}\right)(CFX)

C'est précisément parce que animal1.age+=inc; Et animal2.age-=inc; L'appel a changé 2- Oui.64B Longueur de l'entrée , Et enregistrer les changements dans blockchain , Analyse avec des exemples donnés précédemment , Le montant du gage doit être inclus dans l'élément instance de la structure modifiée. ageVariables,Ça correspond.2- Oui.64B Longueur de l'entrée , Comme il n'y a pas eu de changement name, En combinaison avec les exemples que nous avons donnés précédemment , Le montant du gage est: :0.125 CFX ( 1 16 ) × 2 = 0.125 C F X \left(\frac{1}{16}\right)×2=0.125(CFX)

Le Code du contrat d'appel est le suivant: :

const { Conflux, util } = require('js-conflux-sdk');
// Cette adresse est imprimée dessus. receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x84dd09cd48e07426c4ac50a389930c034be6c82a';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425*';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812*';
const compiled = require(`./build/Struct_test`)
async function main() {
const cfx = new Conflux({
url: 'http://main.confluxrpc.org',
});
const contract = cfx.Contract({
address : contractAddress,
abi: compiled.abi,
});
const before_call_balance = await cfx.getBalance(public_address);
console.log("before account1 call the current drip:"+before_call_balance.toString());
console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
const account1 = cfx.Account(PRIVATE_KEY1);// Créer un compte avec une clé privée 
// Enregistrer et dépenser CFX
await contract.getAnimal(3).sendTransaction({ from: account1 }).confirmed();
const after_call_balance = await cfx.getBalance(public_address);
console.log("after account1 call getAnimal() the current drip:"+after_call_balance.toString());
console.log("after account1 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
//Créationaccount2, Et essayez d'appeler le contrat pour le libérer. account1Decfx
const account2 = cfx.Account(PRIVATE_KEY2);// Créer un compte avec une clé privée 
const before_account2_call_balance = await cfx.getBalance(public_address);
console.log("before account2 call getAnimal() the current drip:"+after_call_balance.toString());
console.log("before account2 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
await contract.getAnimal(3).sendTransaction({ from: account2 }).confirmed();
const after_account2_call_balance = await cfx.getBalance(public_address);
console.log("after account2 call getAnimal() the current drip:"+after_account2_call_balance.toString());
console.log("after account2 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));
Copier le Code

Pour faciliter la description, Utiliser le compte participant au contrat d'appel account1Etaccount2Représentation, Contrat invoqué contractReprésentation, Résumer ses informations de compte et son adresse de compte correspondante , Les tableaux suivants sont présentés: :

Nom du compte Adresse du compte
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x84dd09cd48e07426c4ac50a389930c034be6c82a

Pour plus de commodité, Ensuite, utilisez le nom du compte dans le tableau ci - dessus pour désigner chaque compte.

Avant d'appeler,UtiliserconfluxscanRegarde.account1CorrespondantCFXSolde, Le solde trouvé est :1983.472904449450987608 CFX.

sample3_scan1

(1)Utiliseraccount1 Faire le premier appel contractuel :

Parce queaccount1AppelégetAnimal() La fonction modifie l'espace de stockage des enregistrements stockés dans le contrat , Et les données modifiées sont enregistrées par blockchain , C'est pour ça qu'il faut le remettre. CFX Comme caution

Après le démarrage du programme:Afficher d'abordaccount1Solde du compte:1983.472904449451016507 CFX.

Le programme utiliseraaccount1Appelezcontract.getAnimal(3) Initier une interaction avec le contrat ,Cette fonction va faire face àanimal1.ageAjouter3Fonctionnement,C'est exact.animal2.ageMoins3Fonctionnement, Trouvé une fois l'appel terminé account1 Le solde du compte pour :1983.347904449450984359 CFX.

sample3_sub_call1

C'est - à - dire passer account1Avec contratcontract Cette interaction , Son compte a été déduit : 1983.472904449451016507 1983.347904449450984359 = 0.125000000000032148 C F X 1983.472904449451016507-1983.347904449450984359=0.125000000000032148(CFX)

Cela signifie qu'en appelant contract.getAnimal(3) Interagir avec le contrat pour modifier les données et écrire des journaux dans blockchain .account1 Montant versé 0.125000000000032148DeCFX.

Utiliseraccount2Contrat d'appel,Pour aideraccount1Libérer de l'espace

Le programme qui invoque le contrat continue de fonctionner ,Et utiliseraccount2Par appelcontract.getAnimal(3) Initier une interaction avec le contrat

Avant d'appeler,account1 Le solde du compte pour :1983.347904449450984359 CFX, À la fin de l'opération précédente account1 Le solde du compte de .

account2 Après avoir appelé le contrat ,account1DeCFX Le solde devient 1983.472904449450984359 CFX

sample3_sub_call2

C'est - à - dire,Passe.account2 Après l'appel au contrat ,account1CompteCFX Variation du solde à : 1983.347904449450984359 1983.472904449450984359 = 0.125 C F X 1983.347904449450984359-1983.472904449450984359=-0.125(CFX)

Cela signifie,Parce queaccount1AppelezgetAnimal() Fonction modifiée et occupée 128Bytes La taille de l'espace contractuel est account2 Appel au contrat libéré ,0.125 CFX Sera retourné à account1Dans le compte de.Suivez les étapes(1) Paiements calculés en :0.125000000000032148 CFX, Nous pouvons spéculer ,account1Appelezcontract.getAnimal(3) Le coût réel est de : 0.125000000000032148 0.125 = 0.000000000000032148 C F X 0.125000000000032148-0.125=0.000000000000032148(CFX)

En cours de programmationaccount1 Avant d'invoquer le contrat , Le programme montre account1DeCFXLe solde est:1983.472904449451016507 CFX.

En cours de programmationaccount2 Après avoir appelé le contrat ,account1ComptesCFXLe solde est:1983.472904449450984359 CFX.

C'est - à - dire qu'après cette interaction avec le contrat, ,account1 Le compte a été déduit 0.000000000000032148- Oui.CFX,La formule de calcul est la suivante:: 1986.673099761952481801 1986.673099761952433413 = 0.000000000000032148 C F X 1986.673099761952481801-1986.673099761952433413=0.000000000000032148(CFX)

On y retourne.confluxscan Voir le compte à account1 Le solde correspondant est: :1983.47290444945095546 CFX

sample3_confluxscan2

Selon la formule de calcul: 1983.472904449450987608 1983.47290444945095546 = 0.000000000000032148 ( C F X ) 1983.472904449450987608-1983.47290444945095546=0.000000000000032148 (CFX) Ça prouve aussi :account1Appelezcontract.getAnimal(3) En interaction avec le contrat , Son compte a effectivement consommé 0.000000000000032148 CFX

4. Un contenantmappingExemples

Le Code du contrat est le suivant::

pragma solidity ^0.5.0;
contract mapping_test {
mapping(address => uint) public balances;
event SelfEvent(address indexed sender,uint current);
function update(uint newBalance) public {
balances[msg.sender] = newBalance;
}
function self() public {
emit SelfEvent(msg.sender, balances[msg.sender]);
}
}
Copier le Code

Utilisé dans ce contrat mapping Structure, Parce qu'un de ces contrats intelligents contient mapping(address => uint) balance; , Et quand la fonction associée est appelée ,Sera mis à jour address Données des entrées correspondantes , L'appel a changé 1- Oui.64B Longueur de l'entrée , Et enregistrer les changements dans blockchain , Analyse avec des exemples donnés précédemment , Il est temps de donner en gage 0.0625- Oui.CFX.

Le Code du contrat d'appel est le suivant: :

const { Conflux, util } = require('js-conflux-sdk');
// Cette adresse est imprimée dessus. receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x8433f943dd6a4cbf13209b9e8674c08349872ce8';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb977';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c';
const compiled = require(`./build/mapping_test`)
async function main() {
const cfx = new Conflux({
url: 'http://main.confluxrpc.org',
});
const contract = cfx.Contract({
address : contractAddress,
abi: compiled.abi,
});
const before_call_balance = await cfx.getBalance(public_address);
console.log("before account1 call the current drip:"+before_call_balance.toString());
console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
const account1 = cfx.Account(PRIVATE_KEY1);// Créer un compte avec une clé privée 
// Enregistrer et dépenser CFX
await contract.update(3).sendTransaction({ from: account1 }).confirmed();
const after_call_balance = await cfx.getBalance(public_address);
console.log("after account1 call update() the current drip:"+after_call_balance.toString());
console.log("after account1 call update() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
//Créationaccount2, Et essayez d'appeler le contrat pour le libérer. account1Decfx
const account2 = cfx.Account(PRIVATE_KEY2);// Créer un compte avec une clé privée 
const before_account2_call_balance = await cfx.getBalance(public_address);
console.log("before account2 call update() the current drip:"+after_call_balance.toString());
console.log("before account2 call update() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
await contract.update(5).sendTransaction({ from: account2 }).confirmed();
const after_account2_call_balance = await cfx.getBalance(public_address);
console.log("after account2 call update() the current drip:"+after_account2_call_balance.toString());
console.log("after account2 call update() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));
Copier le Code

Pour faciliter la description, Utiliser le compte participant au contrat d'appel account1Représentation, Contrat invoqué contractReprésentation, Résumer ses informations de compte et son adresse de compte correspondante , Les tableaux suivants sont présentés: :

Nom du compte Adresse du compte
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x8433f943dd6a4cbf13209b9e8674c08349872ce8

Pour plus de commodité, Ensuite, utilisez le nom du compte dans le tableau ci - dessus pour désigner chaque compte.

La sortie au moment de l'appel est la suivante: :

Après le démarrage du programme:Afficher d'abordaccount1Solde du compte:98.955078124999570464 CFX.

Le programme utiliseraaccount1Appelezcontract.update(5) Initier une interaction avec le contrat ,Cette fonction va faire face àbalances[msg.sender] Effectuer l'opération de réglage de la nouvelle valeur , Trouvé une fois l'appel terminé account1 Le solde du compte pour :98.892578124999543647 CFX.

C'est - à - dire passer account1Avec contratcontract Cette interaction , Son compte a été déduit : 98.955078124999570464 98.892578124999543647 = 0.062500000000026817 C F X 98.955078124999570464-98.892578124999543647=0.062500000000026817(CFX)

Parce que l'entrée pour la garantie de stockage est 1, Donc le gage 0.0625 CFXC'est vrai, Et il a fallu 0.000000000000026817 (CFX)

本文为[Conflux Chinese community]所创,转载请带上原文链接,感谢
https://fheadline.com/2022/01/202201142252112513.html
相似文章