Tutoriel de développement IBAX
Guide de démarrage
Déploiement
Guide Avancé
Nous allons déployer des smart contracts sur la blockchain IBAX via l'outil en ligne de commande (opens new window) et apprendre comment invoquer des smart contracts.
En tant que premier smart contract, nous l'avons déployé sur le réseau de test local. Pour savoir comment déployer un réseau local, vous pouvez vous référer à Déploiement du réseau,
ainsi vous pouvez le déployer et l'exécuter comme vous le souhaitez sans aucun surcoût.
Créer une application
Appelez le contrat @1NewApplication pour créer l'application, qui a un paramètre de nom d'application et un paramètre de permission de modification.
Les éléments suivants sont expliqués par ligne :
- Ligne 1, démarrer le terminal de ligne de commande
- Ligne 5, appeler le contrat @1NewApplication pour créer une application avec le nom d'application
testapp
et la permission de modification de l'application @1DeveloperCondition
avec la permission du développeur - Ligne 8, l'identifiant de bloc généré par la transaction
- Ligne 9, le hachage de bloc généré par la transaction
- Ligne 10, si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité)
- Ligne 11, si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'identifiant de bloc est renvoyé, le champ err est l'identifiant de l'application
Bien sûr, si vous souhaitez voir quels champs et types de champs sont disponibles dans ce contrat, vous pouvez appeler la méthode getContractInfo
, qui renverra les informations sur le contrat comme suit:
Le champ fields
est constitué des paramètres du contrat, incluant le nom du paramètre name
, type
, optional
, Name
et Conditions
sont requis, VotingId
est optionnel, consultez la méthode API contract/name
Rédaction de contrats
Nous utilisons Needle pour écrire un contrat intelligent.
Nous implémentons une opération d'addition simple, le code source du contrat est le suivant, nous enregistrons le contrat sous le nom SumMath.sim
.
Le suivant est expliqué par ligne :
- À la ligne 1, nous définissons un contrat avec le nom SumMath.
- Ligne 2, Section des données.
- Aux lignes 3-4, nous définissons deux paramètres de type entier 64 bits en entrée,
A
et B
. - Ligne 6, Section conditionnelle.
- Ligne 9, Section des opérations. Nous définissons une variable
sum
pour recevoir le résultat de A+B.
Nous assignons la valeur de sum
à $result
, en tant que résultat du contrat. Bien sûr, il est possible d'assigner directement la valeur de A+B à $result
, mais cela peut être montré comme un exemple.
Créer un contrat
Il existe deux façons de créer un contrat, dont la première est la suivante :
Dans la première étape, nous rédigeons un fichier de paramètres de contrat au format json :
où ApplicationId
est l'identifiant de l'application, Value
est le code source du contrat, il est nécessaire d'échapper les caractères spéciaux, Conditions
sont les droits de modification du contrat.
Nous l'avons nommé SumMathParams.json.
La deuxième étape consiste à appeler la création d'un contrat @1NewContract:
Deuxième méthode :
Le fichier source du contrat enregistré est directement transmis aux paramètres du contrat dans le format de paramètre nomParamètre
+ -
+ "fichier", nomParamètre-fichier
comme suit :
Le suivant est expliqué par ligne :
- Ligne 1 : Appeler le contrat @1NewContract pour créer le contrat, -f utilise le fichier pour importer les paramètres du contrat
- Ligne 3 : L'identifiant de bloc généré par la transaction
- Ligne 4 : Le hachage de bloc généré par la transaction
- Ligne 5 : Si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité)
- Ligne 6 : Si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'identifiant de bloc est renvoyé, le champ err est l'identifiant du contrat
Essayons d'appeler le contrat que nous venons de déployer.
L'appel est terminé et le résultat est conforme aux attentes, comme expliqué ci-dessous par ligne :
- La première ligne appelle le contrat, ici nous déployons le contrat dans l'écosystème avec l'identifiant écologique 5. Bien sûr, si l'identifiant écologique actuel est 5, dans le même écosystème, vous pouvez également appeler
callContract SumMath {"A":1, "B":2}
de cette manière. - Ligne 3, l'identifiant de bloc généré par la transaction.
- Ligne 4, le hachage de bloc généré par la transaction.
- Ligne 5, si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité).
- Ligne 6, si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'identifiant de bloc est renvoyé, le champ err est le résultat du contrat, qui est la valeur de
$result
.
Dans ce tutoriel, vous apprendrez comment :
Afin de comprendre plus clairement à quoi ressemble l'écosystème et les applications IBAX et ce qu'ils font, il est préférable de comprendre où l'écosystème et les applications devraient appartenir, et nous pouvons mieux comprendre avec une carte mentale simple :
Il est possible de constater que les réseaux IBAX peuvent avoir de nombreux Écosystèmes.
Chaque écosystème peut avoir plusieurs applications.
Chaque application possède un contrat.
Tables.
Chaque écosystème possède des paramètres écologiques, chaque application possède des paramètres d'application.
Étape 1 : Créer un écosystème
Nous commençons par créer un écosystème en utilisant l'outil en ligne de commande (https://github.com/IBAX-io/ibax-cli), en appelant le contrat @1NewEcosystem.
Si vous souhaitez changer le nom de l'écosystème, vous pouvez appeler le contrat @1EditEcosystemName.
Les éléments suivants sont expliqués par ligne :
- Ligne 1, qui lance le programme de console de ligne de commande
- Ligne 5, appelle le contrat
@1NewEcosystem
pour créer un écosystème avec le nom "test ecosystem" - Ligne 8, l'identifiant de bloc généré par la transaction
- Ligne 9, le hachage de bloc généré par la transaction
- Ligne 10, si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité)
- Ligne 11, si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'identifiant de bloc est renvoyé, le champ d'erreur est l'identifiant de l'écosystème en tant que
18
Ensuite, nous configurons l'outil de commande config.yml
, nous définissons ecosystem
sur l'ecid créé 18
et redémarrons le programme de console de ligne de commande:
Étape 2 : Créer une application
Appeler le contrat @1NewApplication
pour créer l'application, qui a un paramètre de nom d'application et un paramètre de modification Paramètre de Permission
Si vous devez modifier les autorisations de l'application, vous pouvez appeler le contrat EditApplication
.
Ce qui suit est expliqué par ligne :
- Ligne 1, appelez le contrat @1NewApplication pour créer une application, le nom de l'application est
GradesRecorder
, la permission de modification de l'application est la permission du développeur @1DeveloperCondition
. - Ligne 4, l'ID de bloc généré par la transaction.
- Ligne 5, le hachage de bloc généré par la transaction.
- Ligne 6, si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité).
- Ligne 7, si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'ID de bloc est renvoyé, le champ err contient l'ID de l'application qui est
47
.
Écrivons un exemple simple d'une application qui suit les notes des étudiants.
Les champs de la table de données comprennent les informations sur l'étudiant, la note grade
, la classe class
, les notes de matières mathématiques, physique, littérature
, le score global overall_score
, la note score
, le timestamp de création (ms) created_at
.
Étape 3 : Créer une table
Dans la première étape, nous rédigeons un fichier de paramètres de contrat au format json :
où ApplicationId
est l'identifiant de l'application, Name
est le nom de la table de données créée test_table
.
ColumnsArr
est un tableau de champs de la table de données, TypesArr
est le type des champs de la table de données, comprenant 9 types varchar
, character
, json
, number
, datetime
, double
, money
, text
, bytea
, le nom du champ et le type de champ sont en correspondance un à un. InsertPerm
pour la permission de nouvelle entrée dans la table de données, UpdatePerm
pour la permission de mise à jour des entrées de la table de données, ReadPerm
pour la permission de lecture des données de la table de données, NewColumnPerm
pour la permission de nouveau champ de la table de données.
En référence au Contrôle des autorisations, ici ContractConditions(\"MainCondition\")
est disponible pour le créateur de l'écosystème actuel.
Nous l'appelons createTable.json, puis nous appelons le contrat pour créer la table de données @1NewTableJoint
.
Modifier les autorisations des champs de la table de données
Nous pouvons modifier les autorisations des champs de la table de données. Les autorisations des champs de la table de données comprennent les autorisations de lecture et de mise à jour. Les autorisations de lecture permettent d'utiliser le filtre DBFind.Columns
dans le contrat ou des interfaces telles que list pour effectuer des requêtes. Si aucune autorisation n'est accordée, une erreur de permission sera signalée.
La permission de mise à jour est la permission de modifier les champs de la table de données.
Nous avons défini les autorisations de lecture et de mise à jour du champ "student" sur "false", mais bien sûr, elles peuvent être rendues opérationnelles par certains contrats.
Appelez le contrat @1EditColumn
pour modifier les autorisations des champs de la table de données.
Nous pouvons créer plusieurs paramètres d'application : grade_best_type
, grade_type_a+
, grade_type_a
, grade_type_b+
, grade_type_b
, grade_type_c
, type de notation des grades.
Étape 4 : Créer les paramètres de l'application
Appelez le contrat @1NewAppParam
pour créer les paramètres de l'application. Si vous souhaitez modifier les paramètres de l'application, vous pouvez appeler le contrat @1EditAppParam
.
Où grade_best_type
est le meilleur type de notation.
grade_type_a+
est la condition déclenchée par la notation A+
, lorsque le score est supérieur ou égal à 90 et inférieur à 101, la notation est A+
, les autres paramètres sont similaires.
Étape 5 : Créer un contrat et le déployer.
Nous créons un contrat pour enregistrer les informations de notes des étudiants et leur note finale pour chaque matière, et nous saisissons la classe et la note de l'étudiant pour chaque matière lors de la saisie des informations.
En fonction des notes saisies pour chaque matière, nous effectuons un calcul de moyenne pour obtenir la note globale overallScore
et la note finale score
.
Lorsque le contrat est appelé, il créera un enregistrement dans la table de données que nous venons de créer grade_info
.
D'abord, nous écrivons un contrat et le nommons NewRecord.sim
Ce qui suit est expliqué par ligne:
- Ligne 2, section des données définit les paramètres d'entrée
Student
nom de l'étudiant, Grade
classe, Class
classe, Mathematics
score en mathématiques, Physics
score en physique, Literature
score en littérature. - Ligne 10, la fonction getScore, produit un score composite et une note finale basée sur le score de chaque matière.
- Ligne 30, la fonction safeJsonDecode, décode la chaîne JSON et la convertit en map.
- Ligne 38, section conditionnelle.
- Ligne 39, section des opérations.
Comme vous pouvez le voir, lorsque le contrat est appelé, il passe d'abord par la partie conditionnelle, vérifiant que les paramètres d'entrée du contrat sont valides, tels que le nom de l'étudiant if Size($Student) == 0 {
est vide (ligne 39), et s'il l'est, un message d'erreur est renvoyé "L'étudiant ne peut pas être vide"
(ligne 30). Après avoir vérifié tous les paramètres d'entrée, à la ligne 61, utilisez DBFind pour récupérer les informations de la base de données pour l'application avec l'ecid 18
et le nom de l'application GradesRecorder
et les informations de l'application avec deleted=0
ne sont pas supprimées.
Aux lignes 69-74, utilisez AppParam pour récupérer les paramètres de l'application, par exemple $gradeBestType = AppParam(app_id, "grade_best_type", $ eId)
(ligne 69).
Si le paramètre de l'application est stocké au format json, tel que grade_type_a
, vous pouvez vous référer à $gradeTypeABest = safeJsonDecode(AppParam(app_id, "grade_type_a+", $eId))
, qui obtiendra le paramètre de l'application par la fonction safeJsonDecode au format map.
Ensuite, passez à la partie opérationnelle, appelez la fonction getScore pour obtenir le score composite résultant et la note finale (ligne 10), utilisez une map pour stocker, ligne 79, définissez une map pour stocker les informations de réussite de l'étudiant, et
DBInsert Insérez les données dans la table de données @18grade_info
.
Il existe deux façons de créer un contrat, la première consiste à:
Tout d'abord, nous écrivons un fichier de paramètres de contrat au format json:
Où ApplicationId
est l'identifiant de l'application, qui doit être échappé pour les caractères spéciaux, et Conditions
est la permission de modification du contrat.
Code source du contrat Value
, que nous enregistrons sous le nom NewRecordParams.json
.
Après avoir rédigé le contrat, nous devons le déployer en appelant CreateContract@1NewContract
.
La ligne suivante est expliquée par ligne :
- Ligne 1 : appeler le contrat
@1NewContract
pour créer le contrat, -f utilise le fichier pour importer le fichier NewRecord.json
nouvellement créé en tant que paramètre du contrat. - Ligne 3 : l'identifiant de bloc généré par la transaction.
- Ligne 4 : le hachage de bloc généré par la transaction.
- Ligne 5 : si l'exécution de la transaction échoue (0 : pas de pénalité, 1 : pénalité).
- Ligne 6 : si l'exécution de la transaction échoue, un message d'erreur est renvoyé, et si l'identifiant de bloc est renvoyé, le champ d'erreur contient l'identifiant du contrat qui est
348
.
Deuxième méthode :
Le fichier source du contrat enregistré est directement transmis aux paramètres du contrat dans le format de paramètre nomParamètre
+ -
+ "fichier", nomParamètre-fichier
comme suit :
Essayons d'appeler le contrat que nous venons de créer.
The call is complete, and then we check to see if the data table has saved a record
Vous pouvez voir qu'il y a déjà un enregistrement dans la table de données, student
tom avec une note globale de 56 et une note de C.
L'exemple ci-dessus est uniquement à des fins d'étude et de recherche, vous devez modifier les paramètres pertinents en fonction de la situation réelle, tels que la permission d'écriture dans la table de données, la permission de modification de contrat, etc.
Par exemple, si nous voulons spécifier qu'une seule personne peut appeler ce nouveau contrat et que personne d'autre ne peut l'appeler, nous pouvons définir un paramètre écologique new_record_account
.
Étape 6 : Créer des paramètres écologiques
Appeler le contrat @1NewParameter
créera l'éco-paramètre new_record_account
dans la table @1parameters
. Si vous avez besoin de modifier l'éco-paramètre, vous pouvez appeler @1EditParameter
.
Nous créons un paramètre d'écosystème appelé new_record_account
, nous définissons la valeur sur la cléId 6667782293976713160
, nous modifions les permissions pour ContractConditions("MainCondition")
, ce qui signifie que le créateur écologique actuel peut modifier.
Lorsque la transaction est exécutée avec succès, l'identifiant du paramètre écologique dans le champ "err" est 273
.
Étape 7 : ajouter la localisation
Vous pouvez appeler le contrat @1NewLangJoint
pour créer le paramètre de localisation account_not_access
, qui créera le paramètre dans la table @1languages
, et vous pouvez modifier le paramètre de localisation via @1EditLangJoint
.
Étape 8 Modifier le contrat
Ensuite, nous devons modifier la section conditions
du code source du contrat en ajoutant le code suivant aux conditions
.
Appeler pour modifier le contrat @1EditContract, où Id
est l'identifiant du contrat, Value
est le code source du contrat.
Étape 9 Modifier les autorisations de la table de données
Ici, nous devons modifier l'autorisation d'insertion de la table de données, l'autorisation d'origine ContractConditions("MainCondition")
pour l'écréateur, et le paramètre de contrat new_record_account
n'est pas l'écréateur.
Donc, il suffit de modifier ContractConditions("MainCondition")
pour spécifier que le contrat peut opérer sur ContractAccess("@18NewRecord")
.
Appelez le contrat @1EditTable
pour modifier les autorisations de la table de données.
Ensuite, appelez le contrat que vous venez de modifier et créez un nouvel enregistrement.
Vous pouvez voir que le paramètre de localisation que nous venons de définir, account_not_access
, fonctionne.
Nous avons constaté que l'erreur de permission est signalée, l'utilisateur actuel n'a pas l'autorisation d'effectuer des opérations. Nous passons au compte avec l'identifiant de clé 6667782293976713160
et nous pouvons obtenir les informations de l'utilisateur actuel à l'aide de l'outil en ligne de commande account info
.
Configurez le fichier de configuration de l'outil en ligne de commande config.yml et passez au compte avec l'identifiant de clé 6667782293976713160
.
Une fois la configuration terminée, appelez à nouveau le contrat.
L'appel est terminé, interrogeant la table de données via getList @18grade_info
, et le résultat est conforme aux attentes.
Nous espérons que cet article vous a aidé à en savoir plus sur le fonctionnement du réseau IBAX et sur la façon d'écrire un code Needle
clair et sécurisé.
Dans ce tutoriel, vous apprendrez comment :
Avant de commencer ce tutoriel, vous devez avoir votre propre application et connaître le concept d'écosystème et d'application. Vous pouvez vous référer au Guide de démarrage.
Nous importerons l'application sur la blockchain IBAX via l'outil en ligne de commande ibax-cli (opens new window). Exporter une application.
Exporter l'application
Appeler account info
pour interroger les informations du compte actuel, ici le login ecid est 9
, appeler la commande getList
pour interroger les applications associées à l'ecid actuel.
Nous pouvons voir que l'écosystème actuel compte 6 applications. Nous utilisons la commande export
pour exporter l'application avec l'id
de 36
.
Le paramètre -f ici enregistre l'application exportée dans le fichier data.json
dans le répertoire actuel.
Si aucun paramètre -f n'est spécifié, les données de l'application seront affichées dans le terminal de commande.
La commande export
encapsule les étapes pour exporter une application. Vous pouvez utiliser la commande ci-dessus pour exporter une application, ou suivre les étapes suivantes, comme suit :
Appeler le contrat @1ExportNewApp
pour exporter une nouvelle application générera un enregistrement dans la table 1_buffer_data
pour l'application exportée.
Appelez le contrat @1Export
pour exporter l'application, recherchez l'application sélectionnée dans la table 1_buffer_data
, et exportez toutes les ressources de l'application vers la chaîne JSON générée.
La chaîne JSON générée sera écrite dans la table 1_binaries
de l'écosystème actuel.
Interrogez les données dans la table 1_binaries
avec la commande getList
.
Obtenez l'identifiant binaire et le hachage.
Appelez la commande binaryVerify
pour exporter le fichier binaire.
Importer l'application
Utilisez la commande import
pour importer une application, avec le paramètre -f
pour spécifier le fichier d'application à importer.
The import
command encapsulates the steps to import an application, you can use the above command to import an application
Or use the following steps, which, for ease of study and research, are as follows:
- Étape 1 :
Appeler le contrat
@1ImportUpload
pour importer une nouvelle application générera un enregistrement dans la table 1_buffer_data
pour l'application exportée.
@1ImportUpload
Le paramètre du contrat Data
est file
type.
Il contient les mots-clés Name
pour le nom du fichier (chaîne de caractères), MimeType
pour le type de fichier (chaîne de caractères), Body
pour le contenu du fichier ([]byte).
Vous devez encoder en base64 les données du fichier de l'application et les passer dans Body
, vous pouvez utiliser la commande base64Encode
pour les encoder en base64.
- Étape 2 :
Après que l'appel est terminé, utilisez la commande
getList
pour interroger les données dans la table 1_buffer_data
.
- Étape 3 :
Assemblez les données de value.data->Data dans un tableau unidimensionnel, [a,b,c,d].
Ensuite, créez un fichier de paramètres de contrat
importParams.json
, avec le contenu suivant :
- Étape 4 : Appelez le contrat
@1Import
pour importer les données de l'application.
Dans ce tutoriel, vous apprendrez comment :
Avant de commencer ce tutoriel, vous devez avoir votre propre application et connaître le concept d'écosystème et d'application. Vous pouvez vous référer au Guide de démarrage.
Nous allons effectuer la configuration écologique sur la blockchain IBAX via l'outil en ligne de commande ibax-cli (opens new window).
Postuler pour rejoindre l'écosystème{#apply-to-join-the-ecosystem}
Nous pouvons appeler le contrat @1MembershipRequest
pour demander à rejoindre l'écosystème.
L'exemple suivant:
Demande de rejoindre l'écosystème avec l'identifiant écologique 19
, le contrat @1MembershipRequest
impose une restriction sur l'appel de l'écosystème, seul l'écosystème de base peut être appelé.
Lorsque la demande est acceptée, le gestionnaire de l'écosystème cible recevra une demande et elle ne sera considérée comme faisant partie de l'écosystème cible que lorsque la demande sera approuvée par le gestionnaire de l'écosystème.
Bien sûr, si l'écosystème cible est public, vous pouvez le rejoindre directement.
Ajouter des membres de l'écosystème
Lorsque l'écosystème vient d'être créé, le seul membre de l'écosystème est le créateur de l'écosystème. Lorsque vous souhaitez inviter d'autres membres à rejoindre, vous devez connaître la clé publique de la personne invitée, puis appeler le contrat @1MembershipAdd
pour ajouter des membres.
Si l'écosystème est public et permet à n'importe qui de rejoindre, vous pouvez définir le paramètre de l'écosystème free_membership
= 1, qui n'est pas public par défaut.
Une fois configuré, vous n'avez pas besoin d'être approuvé pour rejoindre votre écosystème.
Si vous ne définissez pas le paramètre free_membership
, lorsque d'autres membres demandent à rejoindre votre écosystème, vous recevrez une notification de demande.
Appelez l'application d'approbation du contrat @1MembershipDecide
, les paramètres du contrat NotificId
sont l'identifiant de la notification, 'Accept' est la marque de résolution, la marque de résolution 1
est acceptée.
Blocage des comptes
Appeler le contrat @1DeleteMember
pour geler le compte, notez que cette opération ne peut pas être restaurée.
Gestion des rôles
Création d'un nouveau rôle
Appeler le contrat @1RolesCreate
pour créer un nouveau rôle, nom du rôle student
, type 2
(1 - Assignable 2 - Élu par vote 3 - Système).
Le résultat de retour contient l'identifiant de rôle 21
.
Ajout de membres de rôle
Il existe deux méthodes, la première méthode consiste à ce que le membre de l'écosystème initie la demande d'application en appelant le contrat @1RolesRequest
pour demander à être ajouté en tant que membre du rôle, où Rid
est l'identifiant du rôle.
Dans la deuxième méthode, le gestionnaire de rôles attribue des membres de rôle, et le gestionnaire de rôles appelle le contrat @1RolesAssign
pour ajouter des membres au rôle.
Supprimer les membres du rôle
Tout d'abord, nous voyons quels membres un rôle possède, que nous pouvons interroger via getList, comme suit:
Où la condition where
ecosystem
spécifie l'écosystème, role->id
spécifie l'identifiant du rôle et deleted
: 0 spécifie non supprimé.
Nous pouvons voir que nous avons 3 lignes, si nous voulons supprimer le rôle avec le membre 1273-2644-xxxx-5846-6598
, c'est-à-dire le rôle avec l'id
de 21
.
Les administrateurs peuvent appeler le contrat @1RolesUnassign
pour supprimer les membres du rôle, comme suit:
Modifier le gestionnaire de rôles
Regardons les rôles écologiques actuels :
où roles_access
est le rôle administratif pour le rôle actuel, qui est un tableau et peut en avoir plusieurs.
Nous ajoutons un rôle administratif au rôle teacher
en appelant le contrat @1RolesAccessManager
, où les paramètres du contrat sont Action
l'opérateur administratif (clean
, remove
, add
), Rid
l'ID du rôle à gérer, ManagerRid
l'ID du gestionnaire de rôle.
Supprimer le rôle
Nous pouvons appeler le contrat @1RolesDelete
pour supprimer des rôles, où les paramètres du contrat Rid
sont l'ID du rôle à gérer et Ops
est l'opérateur (D
pour supprimer, R
pour restaurer).
Émission de jeton
Créer un écosystème
Créez un écosystème, appelez le contrat @1NewEcosystem
.
Ensuite, nous modifions la configuration de l'outil en ligne de commande pour se connecter à cet écosystème nouvellement créé : "21".
Installation des applications de base
Appelez le contrat pour installer l'application de base, comme suit :
Ligne 1, installez l'application de plateforme ;
Ligne 2, installez le rôle par défaut ;
Ligne 3-4, installez l'application de configuration écologique et d'émission de jetons, où l'ID de l'application 5,6
peut être consulté via getList comme suit :
Émission de jetons
Parce qu'il s'agit d'un nouvel écosystème, vous devez configurer l'émission de jetons, appelez le contrat @1TeSettings
pour spécifier les rôles pouvant émettre des jetons.
Où RoleDeveloper
est l'identifiant actuel du rôle écologique, qui peut être obtenu via la table de données @1roles
.
Émission de jetons Appeler le contrat @1NewToken
pour émettre des jetons.
Où les paramètres du contrat Symbol
sont le symbole du jeton, Name
est le nom du jeton, Amount
est le montant total et Digits
est la précision.
Émission de jetons
Détruire les jetons
Incrément de jeton par défaut et destruction de jeton sont autorisés, vous pouvez les désactiver en utilisant @1TeChange
, où TypeChange
est le type (emission
pour l'incrément, withdraw
pour la destruction).
Value
est l'état activé/désactivé (1
activé, 2
désactivé), par exemple:
Ajouts fermés.
Note: Ne peut pas être activé après la fermeture.
Désactiver la destruction, si vous souhaitez réactiver la destruction, il suffit de définir la valeur de Value
sur 1
.
Déduction de l'écosystème
Avant de mettre en place des déductions écologiques, vous devez comprendre le modèle de frais IBAX, qui peut être trouvé dans le livre blanc (opens new window).
Nous commençons par définir l'adresse du portefeuille écologique, appelons le contrat @1EditParameter
et modifions les paramètres écologiques.
Où Id
est l'identifiant du paramètre ecosystem_wallet
de l'ecowallet, qui peut être interrogé comme suit :
La valeur Value
est l'adresse de l'ecowallet qui sera liée, et le contrat génère les frais de gaz, qui sont payés par cette adresse. L'adresse doit avoir suffisamment de jetons dans l'écosystème actuel et doit être approuvée par l'adresse liée avant que la modification ne soit réussie.
Appeler le contrat @1EcoFeeModeManage
pour configurer la déduction multi-écologique, comme suit :
Où les champs de paramètres du contrat sont définis comme suit :
- Le paramètre
FollowFuel
est un multiple du taux d'éco-suivi 1. CombustionFlag
indique s'il faut activer la combustion des frais de gaz d'éco-échange, 1 - non, 2 - oui. CombustionPercent
est le pourcentage de combustion, uniquement valable lorsque la combustion des frais de gaz est activée, prend des valeurs de 1 à 100, 0 lorsque ce n'est pas activé. VmCostFlag
est le drapeau des coûts de VM, définissant le paiement direct ou par procuration, 1 - paiement direct, 2 - paiement par procuration. StorageFlag
est le drapeau des frais de stockage, définissant le paiement direct ou par procuration, 1 - paiement direct, 2 - paiement par procuration. ExpediteFlag
est le drapeau des frais d'expédition accélérée, définissant le paiement direct ou par procuration, 1 - paiement direct, 2 - paiement par procuration. VmCostConversionRate
est le taux de conversion des coûts de la machine virtuelle, avec 2 décimales, uniquement valable pour les paiements par procuration, supérieur à zéro. StorageConversionRate
est le taux de conversion des coûts de stockage, avec 2 décimales, uniquement valable pour les paiements par procuration, supérieur à zéro.
Si vous utilisez les paramètres ci-dessus, tous les frais de transaction encourus par les utilisateurs invoquant des contrats au sein de l'écosystème seront payés par le portefeuille écologique de la configuration écologique actuelle.
Tous les utilisateurs n'ont besoin de payer que les frais de gaz encourus au sein de l'écosystème. Bien sûr, vous pouvez ajuster les paramètres de coût selon vos besoins réels.
Écosystème de gouvernance DAO
Avant de modifier vers un écosystème de gouvernance DAO, vous devez vous assurer que l'écosystème actuel a émis des jetons, et après la modification vers un écosystème de gouvernance DAO, toutes les propositions de l'écosystème seront soumises au vote des membres du comité de gouvernance.
Le Conseil de gouvernance DAO n'est plus géré uniquement par les développeurs de l'écosystème, mais les 50 principaux représentants des détenteurs de l'écosystème sont élus.
Call the @1EditControlMode
contract to change the eco governance mode to DAO governance mode.
Où le paramètre Value
1
représente le modèle du créateur et 2
représente le modèle de gouvernance DAO.
Nous pouvons essayer de créer une application.
À ce stade, une proposition de gouvernance DAO est générée et votée par le Conseil de gouvernance de la DAO avant la création de l'application. Une proposition valide nécessite un taux d'approbation de 68% sur 75% des votes exprimés.
Le champ d'application de la gouvernance DAO comprend :
- Ajouter, supprimer et modifier des applications, des contrats, des pages, des extraits de code, des onglets, des menus, des paramètres d'application, des tables de données et des champs.
- Modifier le multilingue.
- Changer le modèle de DAO et de créateur.
- Modifier les paramètres écologiques.
- Rôle, assigner ou supprimer des membres de rôle.
- Émettre une monnaie de destruction supplémentaire.
- Modifier les paramètres de la plateforme.
- Modifier les informations écologiques.
- Modification des contrats différés.
- Modifier le modèle de vote.
Avant de commencer ce tutoriel, vous devez télécharger Outil de conditionnement d'application IBAX (opens new window). Nous devons utiliser cet outil pour empaqueter l'application IBAX.
Nous devons stocker les fichiers de l'application selon la structure de répertoire suivante :
Comme indiqué ci-dessous:
Le répertoire app_params
stocke le fichier des paramètres de l'application, nommé en utilisant le nom du paramètre + le format de fichier .csv
, le contenu du fichier étant la valeur du paramètre.
Le répertoire contracts
contient les contrats, au format de fichier .sim
, et le contenu du fichier est le code source du contrat.
Le répertoire tables
contient la structure de la table de données de l'application au format de fichier json
, comme suit:
name
est le nom du champ du tableau de données, conditions
est la permission du champ du tableau de données, et type
est le type de champ.
À l'étape 1, nous générons un fichier config.json et le sauvegardons dans le répertoire airdrop avec le contenu suivant :
Là où name
est le nom de l'application, conditions
: est l'autorisation de modifier l'application, puis l'enregistrer dans le répertoire airdrop.
Étape 2, empaquetez l'application, la commande suivante générera l'application airdrop.json
dans le répertoire actuel. Si vous modifiez le contrat ou les paramètres de l'application, vous devez reconditionner l'application.
Nous pouvons importer l'application via l'outil en ligne de commande command line tool (opens new window) comme suit :
Utilisez la commande import
pour importer une application, avec le paramètre -f
pour spécifier le fichier d'application à importer.
Bien sûr, si vous avez une application, vous pouvez également générer la structure complète du répertoire avec la commande suivante: