Projet Go échafaudé pour le cadre de taxonomie de jetons

Blockchain App Builder prend l'entrée de votre fichier de spécification de jeton et génère un projet de chaîne de blocs entièrement fonctionnel.

Le projet génère automatiquement des classes et des fonctions de cycle de vie de jeton, y compris des méthodes CRUD et non CRUD. La validation des arguments, la conversion de paramètres/déconversion des paramètres et la capacité de persistance transparente sont toutes prises en charge automatiquement.

Pour plus d'informations sur le projet échafaudé et les méthodes qui ne sont pas directement liées à des jetons, voir Projet de chaîne Go échafaudé.

Informations de référence :

Modèle

La capacité de persistance transparente, ou ORM simplifié, est saisie dans la classe OchainModel.

package src
type Digicur struct {
    AssetType               string                 `json:"AssetType" final:"otoken"`
    Token_id                string                 `json:"Token_id" id:"true" mandatory:"true" validate:"regexp=^[A-Za-z0-9][A-Za-z0-9_-]*$,max=16"`
    Token_name              string                 `json:"Token_name" final:"digicur"`
    Token_desc              string                 `json:"Token_desc" validate:"max=256"`
    Token_type              string                 `json:"Token_type" final:"fungible" validate:"regexp=^fungible$"`
    Behavior                []string               `json:"Behavior" final:"[\"divisible\",\"mintable\",\"transferable\",\"burnable\",\"holdable\",\"roles\"]"`
    Roles                   map[string]interface{} `json:"Roles" final:"{\"minter_role_name\":\"minter\",\"burner_role_name\":\"burner\",\"notary_role_name\":\"notary\"}"`
    Mintable                map[string]interface{} `json:"Mintable" final:"{\"Max_mint_quantity\":20000}"`
    Divisible               map[string]interface{} `json:"Divisible" final:"{\"Decimal\":1}"`
    Token_to_currency_ratio int                    `json:"Token_to_currency_ratio" validate:"int"`
    Currency_representation string                 `json:"Currency_representation" validate:"string"`
    Metadata                interface{}            `json:"Metadata,omitempty"`
}

Contrôleur

Il n'y a qu'un seul contrôleur principal.

type Controller struct {
    Ctx trxcontext.TrxContext
}

Vous pouvez créer n'importe quel nombre de classes, de fonctions ou de fichiers, mais seules les méthodes définies dans la classe de contrôleur principale peuvent être appelées. Les autres méthodes sont masquées.

Vous pouvez utiliser les méthodes de la trousse SDK de jeton pour écrire des méthodes personnalisées pour votre application d'affaires.

Si vous utilisez plusieurs méthodes de trousse SDK de jeton dans une méthode personnalisée, n'utilisez pas de méthodes qui affecteront les mêmes paires clé-valeur dans la base de données d'état.

Utilisez plutôt la méthode BulkTransferTokens pour transférer vers plusieurs comptes à partir du compte de l'appelant, comme indiqué dans l'extrait de code suivant.

BulkTransferTokens(token_id string, flow: []map[string]interface{})

Note :

Si vous utilisez plus d'une méthode de trousse SDK de jeton dans une méthode personnalisée qui pourrait affecter les mêmes paires clé-valeur dans la base de données d'état, activez l'optimisation MVCC pour les codes de chaîne de jeton. Pour plus d'informations, voir Optimisation MVCC.

Méthodes de jeton générées automatiquement

Blockchain App Builder génère automatiquement des méthodes pour prendre en charge les jetons et les cycles de vie des jetons. Vous pouvez utiliser ces méthodes pour initialiser des jetons, gérer des rôles et des comptes et effectuer d'autres tâches de cycle de vie des jetons sans codage supplémentaire. Les méthodes de contrôleur doivent être publiques pour pouvoir être invoquées. Les noms de méthode publics commencent par un caractère majuscule. Les noms de méthode qui commencent par un caractère minuscule sont privés.

Gestion du contrôle d'accès
Gestion de la configuration de jeton
Gestion du compte
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement des jetons

Méthodes pour la gestion du contrôle d'accès

AddTokenAdmin

Cette méthode ajoute un utilisateur en tant que Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) AddTokenAdmin(org_id string, user_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Admin.AddAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Admin.AddTokenAdmin(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Au succès, un message comprend les détails de l'utilisateur qui a été ajouté comme Token Admin du code de chaîne.

Exemple de valeur renvoyée :

{
    "msg": "Successfully added Token Admin (Org_Id: Org1MSP, User_Id: user1)"
}

RemoveTokenAdmin

Cette méthode supprime un utilisateur en tant que Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) RemoveTokenAdmin(org_id string, user_id string) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Admin.RemoveAdmin", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.Admin.RemoveAdmin(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été supprimé comme Token Admin du code de chaîne.

Exemple de valeur renvoyée :

{"msg":"Successfuly removed Admin (Org_Id Org1MSP User_Id user1)"}

IsTokenAdmin

Cette méthode retourne la valeur booléenne true si l'appelant de la fonction est Token Admin, sinon elle retourne false. Un Token Admin ou un Org Admin peut appeler cette fonction sur tout autre utilisateur du réseau de chaîne de blocs. Les autres utilisateurs ne peuvent appeler cette méthode que sur leur propre compte.

func (t *Controller) IsTokenAdmin(org_id string, user_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Admin.IsTokenAdmin", "TOKEN", map[string]string{"org_id": org_id, "user_id": user_id})
      if err != nil || !auth {
            return false, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Auth.IsUserTokenAdmin(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

La méthode retourne true si l'appelant est un Token Admin, sinon elle retourne false.

Exemple de valeur renvoyée :

{"result":false}

GetAllTokenAdmins

Cette méthode retourne une liste de tous les utilisateurs qui sont des Token Admin du code de chaîne. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetAllTokenAdmins() (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Admin.GetAllAdmins", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.Admin.GetAllAdmins()
}

Paramètres :

aucune

Retourne :

En cas de réussite, une liste JSON d'administrateurs comprend des objets OrgId et UserId.

Exemple de valeur renvoyée :

{"admins":[{"OrgId":"Org1MSP","UserId":"admin"},{"OrgId":"Org1MSP","UserId":"user2"}]}

AddOrgAdmin

Cette méthode ajoute un utilisateur en tant que Org Admin de l'organisation. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée.

func (t *Controller) AddOrgAdmin(org_id string, user_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Admin.AddOrgAdmin", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Admin.AddOrgAdmin(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été ajouté en tant que Org Admin de l'organisation.

Exemple de valeur renvoyée :

{
    "msg": "Successfully added Org Admin (Org_Id: Org1MSP, User_Id: orgAdmin)"
}

RemoveOrgAdmin

Cette méthode supprime un utilisateur en tant que Org Admin d'une organisation. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée.

func (t *Controller) RemoveOrgAdmin(org_id string, user_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Admin.RemoveOrgAdmin", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Admin.RemoveOrgAdmin(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été supprimé en tant que Org Admin de l'organisation.

Exemple de valeur renvoyée :

{
    "msg": "Successfully removed Org Admin (Org_Id Org1MSP User_Id orgAdmin)"
}

GetOrgAdmins

Cette méthode retourne une liste de tous les utilisateurs qui sont des Org Admin d'une organisation. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin.

func (t *Controller) GetOrgAdmins() (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Admin.GetOrgAdmins", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Admin.GetAllOrgAdmins()
}

Paramètres :

aucune

Retourne :

En cas de réussite, une liste JSON comprenant des objets OrgId et UserId.

Exemple de valeur renvoyée :

{
    "admins": [
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin"
        },
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin1"
        },
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin2"
        }
    ]
}

Méthodes de gestion de la configuration de jeton

Init

Cette méthode est appelée lorsque le code de chaîne est déployé. Chaque valeur Token Admin est identifiée par les informations user_id et org_id dans le paramètre obligatoire adminList. user_id est le nom d'utilisateur ou l'ID courriel du responsable de l'instance ou de l'utilisateur qui est connecté à l'instance. org_id est l'ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.

Tout utilisateur Token Admin peut ajouter et supprimer d'autres utilisateurs Token Admin en appelant les méthodes AddTokenAdmin et RemoveTokenAdmin.

func (t *Controller) Init(adminList []admin.TokenAdminAsset) (interface{}, error) {
    list, err := t.Ctx.Admin.InitAdmin(adminList)
    if err != nil {
        return nil, fmt.Errorf("initializing admin list failed %s", err.Error())
    }
    return list, nil
}

Paramètres :

adminList array - Tableau d'informations {user_id, org_id} qui spécifie la liste des administrateurs de jetons. Le tableau adminList est un paramètre obligatoire.

Exemple de paramètre, interface de ligne de commande Mac OSX et Linux :

'[{"user_id":"userid", "org_id":"OrgMSPId"}]'

Exemple de paramètre, interface de ligne de commande Microsoft Windows :

"[{\"user_id\":\"userid\", \"org_id\":\"OrgMSPId\"}]"

Exemple de paramètre, console Oracle Blockchain Platform :

["[{\"user_id\":\"userid\", \"org_id\":\"OrgMSPId\"}]"]

Initialize<Token Name>Token

Cette méthode crée un jeton et initialise les propriétés du jeton. La ressource et ses propriétés sont enregistrées dans la base de données d'état. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) InitializeDigicurToken(asset Digicur) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.Save", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    return t.Ctx.Token.Save(&asset)
}

Paramètres :

asset <Token Class> - La ressource de jeton est transmise en tant que paramètre à cette méthode. Les propriétés de la ressource de jeton sont décrites dans le fichier de modèle.

Retourne :

En cas de réussite, une représentation JSON de la ressource de jeton créée.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "",
    "Token_type": "fungible",
    "Behavior": ["divisible", "mintable", "transferable", "burnable", "roles"],
    "Roles": {
        "minter_role_name": "minter"
    },
    "Mintable": {
        "Max_mint_quantity": 1000
    },
    "Divisible": {
        "Decimal": 2
    },
    "Currency_name": "",
    "Token_to_currency_ratio": 1
}

Update<Token Name>Token

Cette méthode met à jour les propriétés du jeton. Après la création d'une ressource de jeton, seules la propriété token_desc et les propriétés personnalisées peuvent être mises à jour. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) UpdateDigicurToken(asset Digicur) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.Update", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    return t.Ctx.Token.Update(&asset)
}

Paramètres :

asset <Token Class> - La ressource de jeton est transmise en tant que paramètre à cette méthode. Les propriétés de la ressource de jeton sont décrites dans le fichier de modèle.

Retourne :

En cas de réussite, une représentation JSON mise à jour de la ressource de jeton.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "Digital Currency equiv of dollar",
    "Token_type": "fungible",
    "Behavior": ["divisible", "mintable", "transferable", "burnable", "roles"],
    "Roles": {
        "minter_role_name": "minter"
    },
    "Mintable": {
        "Max_mint_quantity": 1000
    },
    "Divisible": {
        "Decimal": 2
    },
    "Currency_name": "",
    "Token_to_currency_ratio": 1
}

GetTokenDecimals

Cette méthode retourne le nombre de décimales qui ont été configurées pour un jeton fractionnaire. Si le comportement divisible n'a pas été spécifié pour le jeton, la valeur par défaut est 0. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetTokenDecimals(token_id string) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetTokenDecimals", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    tokenDecimal, err := t.Ctx.Token.GetTokenDecimals(token_id)
    if err != nil {
        return nil, fmt.Errorf("Error in GetTokenDecimals %s", err.Error())
    }
    response := make(map[string]interface{})
    response["msg"] = fmt.Sprintf("Token Id: %s has %d decimal places.", token_id, tokenDecimal)
    return response, nil
}

Paramètres :

token_id string - ID du jeton.

Retourne :

En cas de succès, une chaîne JSON indiquant le nombre de décimales du jeton.

Exemple de valeur renvoyée :

{"msg":"Token Id: digiCurr101 has 1 decimal places."}

GetTokenById

Cette méthode retourne un objet de jeton s'il est présent dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetTokenById(token_id string) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.Get", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    tokenAsset, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return tokenAsset.Interface(), err
}

Paramètres :

token_id string - ID du jeton.

Retourne :

En cas de réussite, un objet JSON qui représente la ressource de jeton.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "Digital Currency equiv of dollar",
    "Token_type": "fungible",
    "Behavior": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "Roles": {
        "minter_role_name": "minter"
    },
    "Mintable": {
        "Max_mint_quantity": 1000
    },
    "Divisible": {
        "Decimal": 2
    },
    "Currency_name": "",
    "Token_to_currency_ratio": 1
}

GetTokenHistory

Cette méthode retourne l'historique des jetons pour un ID jeton spécifié. Tout utilisateur peut appeler cette méthode.

func (t *Controller) GetTokenHistory(token_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetTokenHistory", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Token.History(token_id)
}

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, un objet JSON qui représente l'historique du jeton.

Exemple de valeur renvoyée :

[
    {
        "IsDelete": "false",
        "Timestamp": "2023-09-01T16:46:33Z",
        "TxId": "12333b8a4f63aa9b3a34072efcbd7df546c6d1e7d82a7a9596e899383656d6f7",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "Currency_name1": "",
            "Divisible": {
                "Decimal": 2
            },
            "Mintable": {
                "Max_mint_quantity": 1000
            },
            "Roles": {
                "minter_role_name": "minter"
            },
            "Token_desc": "updated description",
            "Token_id": "token",
            "Token_name": "fiatmoneytok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-09-01T16:04:25Z",
        "TxId": "99702e2dad7554a5ee4716a0d01d3e394cbce39bea8bade265d8911f30ebad0b",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "Currency_name1": "",
            "Divisible": {
                "Decimal": 2
            },
            "Mintable": {
                "Max_mint_quantity": 1000
            },
            "Roles": {
                "minter_role_name": "minter"
            },
            "Token_desc": "",
            "Token_id": "token",
            "Token_name": "fiatmoneytok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

GetAllTokens

Cette méthode retourne tous les jetons stockés dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetAllTokens() (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetAllTokens", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.Token.GetAllTokens()
}

Paramètres :

aucune

Retourne :

En cas de réussite, un objet JSON qui représente toutes les ressources de jeton.

Exemple de valeur renvoyée :

"payload": [
    {
        "key": "t1",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "Currency_name value",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "Token_desc value",
            "Token_id": "t1",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 2,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

GetTokensByName

Cette méthode retourne tous les objets de jeton portant un nom spécifié. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

func (t *Controller) GetTokensByName(token_name string) (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetTokensByName", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.Token.GetTokensByName(token_name)
}

Paramètres :

token_name string - Nom des jetons à extraire. Le nom correspond à la propriété Token_name dans le fichier de spécification. La valeur est le nom de classe du jeton.

Retourne :

En cas de succès, un objet JSON de toutes les ressources de jeton correspondant au nom.

Exemple de valeur renvoyée :

"payload": [
    {
        "key": "t1",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "Currency_name value",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "Token_desc value",
            "Token_id": "t1",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 999,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    },
    {
        "key": "obp2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "",
            "Token_id": "obp2",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

Méthodes de gestion des comptes

CreateAccount

Cette méthode crée un compte pour un utilisateur et un jeton spécifiés. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes font le suivi des soldes, des soldes bloqués et de l'historique des transactions. Un ID compte est un jeu de caractères alphanumériques, précédé de oaccount~<token asset name>~ et suivi d'un hachage du nom d'utilisateur ou de l'ID courriel (user_id) du responsable de l'instance ou de l'utilisateur connecté à l'instance, de l'ID fournisseur de services d'appartenance (org_id) de l'utilisateur dans l'organisation de réseau courante. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou par Org Admin de l'organisation spécifiée.

unc (t *Controller) CreateAccount(org_id string, user_id string, token_type string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.CreateAccount", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.CreateAccount(org_id, user_id, token_type)
}

Paramètres :

org_id: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
token_type: string - Type du jeton, qui doit être fungible.

Retourne :

En cas de réussite, un objet JSON du compte qui a été créé. Le paramètre BapAccountVersion est défini dans l'objet de compte pour une utilisation interne.

Exemple de valeur renvoyée :

{ 
   "AssetType":"oaccount",
   "AccountId":"oaccount~a73085a385bc96c4a45aa2dff032e7dede82c0664dee5f396b7c5854eeafd4bd",
   "BapAccountVersion": 0,
   "UserId":"user1",
   "OrgId":"Org1MSP",
   "AccountType":"fungible",
   "TokenId":"",
   "TokenName":"",
   "Balance":0,
   "BalanceOnHold":0
}

AssociateTokenToAccount

Cette méthode associe un jeton fongible à un compte. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation concernée.

func (t *Controller) AssociateTokenToAccount(account_id string, token_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.AssociateToken", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.AssociateToken(account_id, token_id)
}

Paramètres :

account_id string - ID du compte.
token_id string - ID du jeton.

Retourne :

En cas de succès, un objet JSON du compte mis à jour. Le paramètre BapAccountVersion est défini dans l'objet de compte pour une utilisation interne.

Exemple de valeur renvoyée :

{ 
"AssetType":"oaccount", 
"AccountId":"oaccount~abc74791148b761352b98df58035601b6f5480448ac2b4a3a7eb54bdbebf48eb", 
"BapAccountVersion": 0,
"UserId":"admin", 
"OrgId":"Org1MSP", 
"AccountType":"fungible", 
"TokenId":"token1", 
"TokenName":"loyaltok", 
"Balance":0, 
"BalanceOnHold":0 
}

GetAccount

Cette méthode retourne les détails du compte pour un utilisateur et un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par AccountOwner du compte.

func (t *Controller) GetAccount(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccount", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetAccountWithStatus(account_id)
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un objet de compte JSON qui inclut les propriétés suivantes :
AccountId - ID du compte d'utilisateur.
UserId - Nom d'utilisateur ou ID courriel de l'utilisateur.
OrgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
TokenId - ID du jeton.
Balance - Solde courant du compte.
BalanceOnHold - Solde bloqué courant du compte.
BapAccountVersion - Paramètre d'objet de compte à usage interne.
Status - Statut courant du compte d'utilisateur.

Exemple de valeur renvoyée :

{
  "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
  "AssetType": "oaccount",
  "Balance": 95,
  "BalanceOnHold": 0,
  "BapAccountVersion": 8,
  "OrgId": "appdev",
  "Status": "active",
  "TokenId": "obp1",
  "TokenName": "obptok",
  "TokenType": "fungible",
  "UserId": "idcqa"
}

GetAccountHistory

Cette méthode retourne les détails de l'historique du compte pour un utilisateur et un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou par AccountOwner du compte.

func (t *Controller) GetAccountHistory(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.History", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.History(account_id)
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un tableau d'objets de compte JSON comprenant les propriétés suivantes :
TxId - ID transaction tel que retourné par le livre.
Timestamp - Heure de la transaction.
IsDelete - Valeur booléenne indiquant si l'enregistrement est supprimé.
Value - Chaîne JSON de l'objet de compte. Le paramètre BapAccountVersion est défini dans l'objet de compte pour une utilisation interne.

Exemple de valeur renvoyée :

[
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:31:15Z",
      "TxId": "adde470a63860ec1013bd5c5987e8a506a48942a91b0f39fc8e561374042bd27",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 100,
          "BalanceOnHold": 0,
          "BapAccountVersion": 1,
          "OrgId": "Org1MSP",
          "TokenId": "t1",
          "TokenName": "obptok",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  },
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:30:23Z",
      "TxId": "8fbeda2ba60ba175091faae5ae369247775f2cba45c4d6d1ead6f0b05be84743",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 0,
          "BalanceOnHold": 0,
          "BapAccountVersion": 0,
          "OrgId": "Org1MSP",
          "TokenId": "t1",
          "TokenName": "obptok",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  },
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:29:54Z",
      "TxId": "19bb296ae71709e91b097ba5d9ebd7f7522095880382fbf5913334a46a6026aa",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 0,
          "BalanceOnHold": 0,
          "BapAccountVersion": 0,
          "OrgId": "Org1MSP",
          "TokenId": "",
          "TokenName": "",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  }
]

GetAccountOnHoldBalance

Cette méthode retourne le solde de blocage courant pour un compte et un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par AccountOwner du compte.

func (t *Controller) GetAccountOnHoldBalance(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccountOnHoldBalance", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      response, err := t.Ctx.Account.GetAccountOnHoldBalance(account_id)
      return response, err
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, une représentation JSON du solde de blocage courant.

Exemple de valeur renvoyée :

{
    "holding_balance": 0,
    "msg": "Total Holding Balance of Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id: Org1MSP, user_id: user1) is 0"
}

GetAllAccounts

Cette méthode retourne une liste de tous les comptes. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

func (t *Controller) GetAllAccounts() (interface{}, error) {
    auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAllAccounts", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.Account.GetAllAccounts()
}

Paramètres :

aucune

Retourne :

En cas de succès, un tableau JSON de tous les comptes.

Exemple de valeur renvoyée :

[
    {
        "key": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
        "valueJson": {
            "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
            "AssetType": "oaccount",
            "Balance": 100,
            "BalanceOnHold": 0,
            "BapAccountVersion": 1,
            "OrgId": "appdev",
            "TokenId": "t1",
            "TokenName": "obptok",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    }
]

GetUserByAccountId

Cette méthode retourne les détails de l'utilisateur (org_id et user_id) pour un compte spécifié. Cette méthode peut être appelée par n'importe quel utilisateur du code de chaîne.

func (t *Controller) GetUserByAccountId(account_id string) (interface{}, error) {
    return t.Ctx.Account.GetUserByAccountById(account_id)
}

Paramètres :

account_id string - ID du compte.

Retourne :

En cas de réussite, un objet JSON contenant les détails de l'utilisateur (org_id, token_id et user_id).

Exemple de valeur renvoyée :

{"org_id":"Org1MSP","token_id":"digiCurr101","user_id":"user1"}

GetAccountBalance

Cette méthode retourne le solde courant pour un compte et un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par AccountOwner du compte.

func (t *Controller) GetAccountBalance(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccountBalance", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      response, err := t.Ctx.Account.GetAccountBalance(account_id)
      return response, err
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, une représentation JSON du solde du compte courant.

Exemple de valeur renvoyée :

{"msg":"Current Balance of oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f is 0","user_balance":0}

GetAllOrgAccounts

Cette méthode retourne une liste de tous les comptes de jeton appartenant à une organisation spécifiée. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée.

func (t *Controller) GetAllOrgAccounts(org_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAllOrgAccounts", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetAllOrgAccounts(org_id)
}

Paramètres :

org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

En cas de succès, une liste de tous les comptes pour l'organisation spécifiée.

Exemple de valeur renvoyée :

[
    {
        "key": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
        "valueJson": {
            "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
            "AssetType": "oaccount",
            "Balance": 0,
            "BalanceOnHold": 0,
            "BapAccountVersion": 0,
            "OrgId": "appdev",
            "TokenId": "token",
            "TokenName": "fiatmoneytok",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "key": "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850",
        "valueJson": {
            "AccountId": "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850",
            "AssetType": "oaccount",
            "Balance": 0,
            "BalanceOnHold": 0,
            "BapAccountVersion": 0,
            "OrgId": "appdev",
            "TokenId": "token",
            "TokenName": "fiatmoneytok",
            "TokenType": "fungible",
            "UserId": "example_minter"
        }
    }
]

Méthodes pour la gestion des rôles

AddRole

Cette méthode ajoute un rôle à un utilisateur et à un jeton spécifiés. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée qui a également le rôle spécifié.

func (t *Controller) AddRole(token_id string, user_role string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      tokenAssetValue, err := t.getTokenObject(token_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Token.AddRoleMember", "TOKEN", map[string]string{"org_id": org_id, "token_id": token_id, "role": user_role})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Token.AddRoleMember(user_role, account_id, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
user_role string - Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification. De même, le rôle notary correspond à la propriété notary_role_name du fichier de spécification.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message avec les détails du compte.

Exemple de valeur renvoyée :

 {"msg":"Successfully added role minter to oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1)"}

RemoveRole

Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou par Org Admin de l'organisation spécifiée qui a également le rôle spécifié.

func (t *Controller) RemoveRole(token_id string, user_role string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      tokenAssetValue, err := t.getTokenObject(token_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Token.RemoveRoleMember", "TOKEN", map[string]string{"org_id": org_id, "token_id": token_id, "role": user_role})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Token.RemoveRoleMember(user_role, account_id, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
user_role string - Nom du rôle à supprimer de l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification. De même, le rôle notary correspond à la propriété notary_role_name du fichier de spécification.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message avec les détails du compte.

Exemple de valeur renvoyée :

{"msg":"successfully removed member_id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) from role minter"}

GetAccountsByRole

Cette méthode retourne une liste de tous les ID compte pour un rôle et un jeton spécifiés. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) GetAccountsByRole(token_id string, user_role string) (interface{}, error) {
    auth, err:= t.Ctx.Auth.CheckAuthorization("Role.GetAccountsByRole", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    return t.Ctx.Role.GetAccountsByRole(token_id, user_role)
}

Paramètres :

token_id string - ID du jeton.
user_role string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'ID compte.

Exemple de valeur renvoyée :

{
    "accounts": [
        "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4"
    ]
}

GetAccountsByUser

Cette méthode retourne une liste de tous les ID compte pour un ID organisation et un ID utilisateur spécifiés. Cette méthode ne peut être appelée que par une valeur Token Admin du code de chaîne, une valeur Org Admin de l'organisation spécifiée ou par la valeur Account Owner spécifiée dans les paramètres.

func (t *Controller) GetAccountsByUser(org_id string, user_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccountsByUser", "TOKEN", map[string]string{"org_id": org_id, "user_id": user_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetAccountsByUser(org_id, user_id)
}

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un tableau JSON d'ID compte.

Exemple de valeur renvoyée :

{
    "accounts": [
        "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4"
    ]
}

GetUsersByRole

Cette méthode retourne une liste de tous les utilisateurs pour un rôle et un jeton spécifiés. Cette méthode ne peut être appelée que par une valeur Token Admin du code de chaîne ou par la valeur Account Owner spécifiée dans les paramètres.

func (t *Controller) GetUsersByRole(token_id string, user_role string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Role.GetUsersByRole", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Role.GetUsersByRole(token_id, user_role)
}

Paramètres :

token_id string - ID du jeton.
user_role string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON des objets utilisateur (org_id et user_id).

Exemple de valeur renvoyée :

{"Users":[{"org_id":"Org1MSP","token_id":"digiCurr101","user_id":"user1"}]}

IsInRole

Cette méthode retourne une valeur booléenne pour indiquer si un utilisateur et un jeton ont un rôle spécifié. Cette méthode ne peut être appelée que par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par AccountOwner du compte.

func (t *Controller) IsInRole(token_id string, org_id string, user_id string, user_role string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(token_id)
      if err != nil {
            return nil, err
      }
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Token.IsInRole", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      result, err := t.Ctx.Token.IsInRole(user_role, account_id, tokenAssetValue.Interface())
      if err != nil {
            return nil, fmt.Errorf("error in IsInRole %s", err.Error())
      }
      response := make(map[string]interface{})
      response["result"] = result
      return response, nil
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.
user_role string - Nom du rôle à rechercher.

Retourne :

En cas de succès, une chaîne JSON du résultat booléen.

Exemple de valeur renvoyée :

{"result":false}

GetOrgUsersByRole

Cette méthode retourne des informations sur tous les utilisateurs qui ont un rôle spécifié dans une organisation spécifiée. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée.

func (t *Controller) GetOrgUsersByRole(token_id string, user_role string, org_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Role.GetOrgUsersByRole", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Role.GetOrgUsersByRole(token_id, user_role, org_id)
}

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à vérifier.
org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

Au succès, une liste de tous les utilisateurs ayant le rôle spécifié dans l'organisation spécifiée.

Exemple de valeur renvoyée :

{
    "Users": [
        {
            "org_id": "Org1MSP",
            "token_id": "token",
            "user_id": "admin"
        },
        {
            "org_id": "Org1MSP",
            "token_id": "token",
            "user_id": "orgAdmin"
        }
    ]
}

GetOrgAccountsByRole

Cette méthode retourne des informations sur tous les comptes qui ont un rôle spécifié dans une organisation spécifiée. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par un élément Org Admin de l'organisation spécifiée.

func (t *Controller) GetOrgAccountsByRole(token_id string, user_role string, org_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Role.GetOrgAccountsByRole", "TOKEN", map[string]string{"org_id": org_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Role.GetOrgAccountsByRole(token_id, user_role, org_id)
}

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à vérifier.
org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

En cas de succès, une liste de tous les comptes ayant le rôle spécifié dans l'organisation spécifiée.

Exemple de valeur renvoyée :

{
    "accounts": [
        "oaccount~abc74791148b761352b98df58035601b6f5480448ac2b4a3a7eb54bdbebf48eb",
         "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850"
    ]
}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

Cette méthode retourne un tableau des détails de l'historique des transactions de compte pour un utilisateur et un jeton spécifiés. Cette méthode ne peut être appelée que par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par AccountOwner du compte.

func (t *Controller) GetAccountTransactionHistory(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccountTransactionHistory", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      transactionArray, err := t.Ctx.Account.GetAccountTransactionHistory(account_id, org_id, user_id)
      return transactionArray, err
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un tableau d'objets de transaction de compte JSON comprenant les propriétés suivantes :
balance - Le solde du compte.
holding_id - ID d'un compte de détention.
onhold_balance - Solde bloqué.
timestamp - Heure de la transaction.
token_id - ID du jeton.
transacted_account - Compte avec lequel la transaction a eu lieu.
transacted_amount - Montant de la transaction.
transaction_id - ID de la transaction.
transaction_type - Type de transaction.

Exemple de valeur renvoyée :

[{
    "balance": 199,
    "onhold_balance": 0,
    "timestamp": "2021-08-16T17:42:32.905+05:30",
    "token_id": "digiCurr101",
    "transacted_account": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "transacted_amount": 1,
    "transaction_id": "otransaction~c8a9fa001aba6e0d8391b034655889df47eb5103713840b999a4ab41f5e57b38",
    "transaction_type": "DEBIT"
}, {
    "balance": 200,
    "onhold_balance": 0,
    "timestamp": "2021-08-16T17:41:59.262+05:30",
    "token_id": "digiCurr101",
    "transacted_account": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "transacted_amount": 100,
    "transaction_id": "otransaction~65a0bf8ae8108baa7495fbab91c205651c055e9f480f6808753287173026aa69",
    "transaction_type": "MINT"
}]

GetAccountTransactionHistoryWithFilters

func (t *Controller) GetAccountTransactionHistoryWithFilters(token_id string, org_id string, user_id string, filters ...account.AccountHistoryFilters) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetAccountTransactionHistoryWithFilters", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      // sample format of filter: []string{"3", "", "2022-01-16T15:16:36+00:00", "2022-01-17T15:16:36+00:00"}
      transactionArray, err := t.Ctx.Account.GetAccountTransactionHistoryWithFilters(account_id, org_id, user_id, filters...)
      return transactionArray, err
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Exemple :

ochain invoke GetAccountTransactionHistoryWithFilters 'token1' 'appbuilder12' 'user_minter' '{"PageSize":10,"Bookmark":"1","StartTime":"2022-01-25T17:41:42Z","EndTime":"2022-01-25T17:59:10Z"}'

[
  {
    "transaction_id": "otransaction~3f9c306b0ef6994885939c1a6eb5f063b06617ecb932d4a043f323ba53d55f9f",
    "transacted_amount": 200,
    "timestamp": "2022-02-15T18:27:13.000Z",
    "token_id": "token1",
    "transacted_account": "oaccount~obptok~26e046c8ba8b98da2cdabb78113d67200581ea3d4eea5aa324
1abd3598e05d05",
    "transaction_type": "DEBIT",
    "balance": 9200,
    "onhold_balance": 0
  },
  {
    "transaction_id": "otransaction~f1d37c3abd5c85c0a399f246d8eb68257c49ab4fe4cdfd3501908583c51c421e",
    "transacted_amount": 200,
    "timestamp": "2022-02-15T18:27:02.000Z",
    "token_id": "token1",
    "transaction_type": "BULKTRANSFER",
    "number_of_sub_transactions": 2,
    "balance": 9600,
    "onhold_balance": 0
  },
  {
    "transaction_id": "otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b",
    "transacted_amount": 200,
    "timestamp": "2022-02-15T18:26:57.000Z",
    "token_id": "token1",
    "transaction_type": "BULKTRANSFER",
    "number_of_sub_transactions": 2,
    "balance": 9800,
    "onhold_balance": 0
  },
  {
    "transaction_id": "otransaction~07331a1f7be99d6750973674a783da9ec9ca17df23747cdf52d388865d93f9a",
    "transacted_amount": 10000,
    "timestamp": "2022-02-15T18:26:30.000Z",
    "token_id": "token1",
    "transacted_account": "oaccount~obptok~88b62f329f20fffc6fc9231cb51019a5e9550c78b657123d140897
62397d2b55",
    "transaction_type": "MINT",
    "balance": 10000,
    "onhold_balance": 0
  }
]

GetSubTransactionsById

Cette méthode retourne un tableau des détails de l'historique des sous-transactions pour une transaction spécifiée.

func (t *Controller) GetSubTransactionsById(transaction_id string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetSubTransactionsById", "TOKEN", map[string]string{"transaction_id": transaction_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetSubTransactionsById(transaction_id)
}

Paramètres :

transaction_id string - ID de la transaction.

Exemple :

ochain invoke GetAccountSubTransactionHistory 'otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b'

[
  {
    "transaction_id": "otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b~c4ca4238a0b923820dcc509a6f75849b",
    "transacted_amount": 100,
    "timestamp": "2022-02-15T18:26:57.000Z",
    "token_id": "token1",
    "transacted_account": "oaccount~obptok~6600eb38d365552b76f41d4186acece104f31eae331a440f963e6fa75b62ff21",
    "transaction_type": "DEBIT",
    "balance": 9900,
    "onhold_balance": 0
  },
  {
    "transaction_id": "otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b~c81e728d9d4c2f636f067f89cc14862c",
    "transacted_amount": 100,
    "timestamp": "2022-02-15T18:26:57.000Z",
    "token_id": "token1",
    "transacted_account": "oaccount~obptok~26e046c8ba8b98da2cdabb78113d67200581ea3d4eea5aa3241abd3598e05d05",
    "transaction_type": "DEBIT",
    "balance": 9800,
    "onhold_balance": 0
  }
]

GetSubTransactionsByIdWithFilters

Cette méthode retourne un tableau des détails de l'historique des sous-transactions pour une transaction spécifiée.

func (t *Controller) GetSubTransactionsByIdWithFilters(transaction_id string, filters ...account.SubTransactionFilters) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetSubTransactionsByIdWithFilters", "TOKEN", map[string]string{"transaction_id": transaction_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetSubTransactionsByIdWithFilters(transaction_id, filters...)
}

Paramètres :

transaction_id string - ID de la transaction.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Exemple :

ochain invoke GetAccountSubTransactionHistoryWithFilters 'otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b' '{"PageSize":10,"Bookmark":"1"}'

[
{
"transaction_id": "otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b~c4ca4238a0b923820dcc509a6f75849b",
"transacted_amount": 100,
"timestamp": "2022-02-15T18:26:57.000Z",
"token_id": "token1",
"transacted_account": "oaccount~obptok~6600eb38d365552b76f41d4186acece104f31eae331a440f963e6fa75b62ff21",
"transaction_type": "DEBIT",
"balance": 9900,
"onhold_balance": 0
},
{
"transaction_id": "otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b~c81e728d9d4c2f636f067f89cc14862c",
"transacted_amount": 100,
"timestamp": "2022-02-15T18:26:57.000Z",
"token_id": "token1",
"transacted_account": "oaccount~obptok~26e046c8ba8b98da2cdabb78113d67200581ea3d4eea5aa3241abd3598e05d05",
"transaction_type": "DEBIT",
"balance": 9800,
"onhold_balance": 0
}
]

GetTransactionById

Cette méthode retourne l'historique d'une ressource Transaction.

func (t *Controller) GetTransactionById(transaction_id string) (interface{}, error) {
    return t.Ctx.Transaction.GetTransactionById(transaction_id)
}

Paramètres :

transaction_id string - ID de l'immobilisation de transaction.

Retourne :

En cas de succès, un tableau JSON de l'historique de la transaction.

Exemple de valeur renvoyée :

{
    "history": [
        {
            "IsDelete": "false",
            "Timestamp": "2021-08-16 20:19:05.028 +0530 IST",
            "TxId": "67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220",
            "Value": {
                "Amount": 3,
                "AssetType": "otransaction",
                "FromAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
                "HoldingId": "ohold~digicur~digiCurr101~op2",
                "NumberOfSubTransactions": 0,
                "Timestamp": "2021-08-16T20:19:05+05:30",
                "ToAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
                "TokenId": "digiCurr101",
                "TransactionId": "otransaction~67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220",
                "TransactionType": "RELEASEHOLD"
            }
        }
    ],
    "transaction_id": "otransaction~67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220"
}

DeleteHistoricalTransactions

Cette méthode supprime les anciennes transactions de la base de données d'état.

func (t *Controller) DeleteHistoricalTransactions(timestamp string) (interface{}, error) {
      auth, err := t.Ctx.Auth.CheckAuthorization("Transaction.DeleteHistoricalTransactions", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Transaction.DeleteHistoricalTransactions(timestamp)
}

Paramètres :

timestamp string - Horodatage qui indique quand supprimer des transactions. Les immobilisations de transaction antérieures à l'heure spécifiée seront supprimées.

Méthodes de gestion du comportement des jetons - Comportement mintable

IssueTokens

Cette méthode émet des jetons, qui sont alors détenus par l'appelant de la méthode. L'appelant doit avoir un compte et le rôle de mineur. Le nombre de jetons pouvant être frappés est limité par la propriété max_mint_quantity du comportement mintable dans le fichier de spécification. Si la propriété max_mint_quantity n'est pas spécifiée, un nombre illimité de jetons peut être pointé. La quantité doit être comprise dans les valeurs décimales spécifiées par le paramètre decimal du comportement divisible dans le fichier de spécification. Cette méthode ne peut être appelée que par AccountOwner du compte doté du rôle de créateur.

func (t *Controller) IssueTokens(token_id string, quantity float64) (interface{}, error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.Mint(quantity, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
quantity float64 - Nombre de jetons à menthe.

Retourne :

En cas de réussite, un message avec les détails du compte.

Exemple de valeur renvoyée :

{"msg":"Successfully minted 100 tokens to account oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1)"}

GetTotalMintedTokens

Cette méthode retourne le nombre total de jetons frappés pour un jeton spécifié. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetTotalMintedTokens(token_id string) (interface{}, error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetTotalMintedTokens", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    return t.Ctx.Token.GetTotalMintedTokens(tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.

Retourne :

En cas de succès, une chaîne JSON indiquant le nombre total de jetons.

Exemple de valeur renvoyée :

{"msg":"total minted amount for token with id digiCurr101 is 1000","quantity":1000}

GetNetTokens

Cette méthode retourne le nombre net total de jetons disponibles dans le système pour un jeton spécifié. Le total net des jetons est la quantité de jetons restants après la combustion des jetons. Sous forme d'équation, jetons nets = jetons totaux frappés - jetons totaux brûlés. Si aucun jeton n'est brûlé, le nombre de jetons nets est égal au nombre total de jetons frappés. Cette méthode ne peut être appelée que par Token Admin ou Org Admin du code de chaîne.

func (t *Controller) GetNetTokens(token_id string) (interface{}, error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    auth, err := t.Ctx.Auth.CheckAuthorization("Token.GetNetTokens", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    return t.Ctx.Token.GetNetTokens(tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.

Retourne :

En cas de succès, une chaîne JSON indiquant le nombre net de jetons.

Exemple de valeur renvoyée :

{"msg":"net minted amount for token with id digiCurr101 is 1000","quantity":1000}

Méthodes de gestion du comportement des jetons - Comportement transférable

TransferTokens

Cette méthode transfère les jetons de l'appelant vers un compte spécifié. L'appelant de la méthode doit avoir un compte. La quantité doit être comprise dans les valeurs décimales spécifiées par le paramètre decimal du comportement divisible dans le fichier de spécification. Cette méthode ne peut être appelée que par AccountOwner du compte.

func (t *Controller) TransferTokens(token_id string, to_org_id string, to_user_id string, quantity float64) (interface{}, error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    to_account_id, err := t.Ctx.Account.GenerateAccountId(token_id, to_org_id, to_user_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.Transfer(to_account_id, quantity, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
to_org_id string - ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
to_user_id string - Nom d'utilisateur ou ID courriel du destinataire.
quantity float64 - Nombre de jetons à transférer.

Retourne :

En cas de succès, un message avec des détails pour les deux comptes.

Exemple de valeur renvoyée :

{"msg":"successfully transferred 1 tokens from account oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) to account oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df (org_id : Org1MSP, user_id : admin)"}

BulkTransferTokens

Cette méthode est utilisée pour effectuer un transfert en masse de jetons du compte de l'appelant vers les comptes spécifiés dans l'objet flow. Les quantités doivent être comprises dans les valeurs décimales spécifiées par le paramètre decimal du comportement divisible dans l'appelant de spécification file.The de cette méthode doit avoir un compte déjà créé. Cette méthode ne peut être appelée que par AccountOwner du compte.

func (t *Controller) BulkTransferTokens(token_id string, flow[]map[string]interface{}) (interface{}, error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.BulkTransfer(flow, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
flow[]map[string]interface{} - Tableau d'objets JSON qui spécifient les détails et les quantités du destinataire.
- to_org_id string - ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
- to_user_id string - Nom d'utilisateur ou ID courriel du destinataire.
- quantity float64 - Nombre de jetons à transférer.
Par exemple :
```
[{
	"to_org_id": "Org1MSP",
	"to_user_id": "user1",
	"quantity": 10
}, {
	"to_org_id": "Org1MSP",
	"to_user_id": "user2",
	"quantity": 10
}]
```

Retourne :

Message indiquant le succès.

Exemple de valeur renvoyée :

{
    "from_account_id": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "msg": "Successfully transferred 2 tokens from Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (Org-Id: Org1MSP, User-Id: user1)",
    "sub_transactions": [
        {
            "amount": 1,
            "to_account_id": "oaccount~digicur~38848e87296d67c8a90918f78cf55f9c9baab2cdc8c928535471aaa1210c706e"
        },
        {
            "amount": 1,
            "to_account_id": "oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df"
        }
    ]
}

Méthodes de gestion du comportement des jetons - Comportement bloquable

HoldTokens

Cette méthode crée un blocage pour le compte du responsable des jetons avec le compte to_account_id. Un compte de notaire est spécifié, qui est responsable de terminer ou de débloquer le blocage. Lorsque le blocage est créé, le solde de jeton spécifié du payeur est bloqué. Un solde bloqué ne peut pas être transféré tant que le blocage n'est pas terminé ou annulé. Un compte doit déjà être créé pour l'appelant de cette méthode. Cette méthode ne peut être appelée que par AccountOwner du compte.

func (t *Controller) HoldTokens(token_id string, operation_id string, to_org_id string, to_user_id string, notary_org_id string, notary_user_id string, quantity float64, TimeToExpiration string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(token_id)
      if err != nil {
            return nil, err
      }
      notary_account_id, err := t.Ctx.Account.GenerateAccountId(token_id, notary_org_id, notary_user_id)
      if err != nil {
            return nil, fmt.Errorf("error in getting notary account id from org_id: %s and user_id: %s with token_id: %s, error %s ", notary_org_id, notary_user_id, token_id, err.Error())
      }
      to_account_id, err := t.Ctx.Account.GenerateAccountId(token_id, to_org_id, to_user_id)
      if err != nil {
            return nil, fmt.Errorf("error in getting to_account id from org_id: %s and user_id: %s with token_id: %s, error %s ", to_org_id, to_user_id, token_id, err.Error())
      }
      return t.Ctx.Token.Hold(operation_id, to_account_id, notary_account_id, quantity, TimeToExpiration, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
operation_id string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
to_org_id string - ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
to_user_id string - Nom d'utilisateur ou ID courriel du destinataire.
notary_org_id string - ID fournisseur de services d'adhésion (MSP) du notaire dans l'organisation courante.
notary_user_id string - Nom d'utilisateur ou ID courriel du notaire.
quantity float64 - Nombre de jetons à mettre en attente.
time_to_expiration - Heure à laquelle le blocage expire. Spécifiez 0 pour un blocage permanent. Sinon, utilisez le format RFC-3339. Par exemple, 2021-06-02T12 :46:06Z.

Retourne :

En cas de succès, un message contenant le compte de l'appelant et contenant les détails.

Exemple de valeur renvoyée :

{"msg":"AccountId oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) is successfully holding 2 tokens"}

ExecuteHoldTokens

Cette méthode met fin à un blocage sur un jeton. Une quantité de jetons précédemment détenus par un propriétaire de jeton est transférée à un destinataire. Si la valeur quantity est inférieure à la valeur de blocage réelle, le montant restant est de nouveau disponible pour le responsable initial des jetons. Cette méthode ne peut être appelée que par l'ID AccountOwner doté du rôle notary. Le blocage ne peut être effectué que par le notaire.

func (t *Controller) ExecuteHoldTokens(token_id string, operation_id string, quantity float64) (interface{} error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.ExecuteHold(operation_id, quantity, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
operation_id string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
quantity float64 - Nombre de jetons bloqués à transférer.

Retourne :

En cas de succès, un message avec l'ID compte de l'appelant et la quantité de la transaction.

Exemple de valeur renvoyée :

{"msg":"Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) has successfully executed '1' tokens(digiCurr101) from the hold with Operation Id 'op1'"}

ReleaseHoldTokens

Cette méthode libère un blocage sur les jetons. Le transfert n'est pas terminé et tous les jetons détenus sont à nouveau disponibles pour le propriétaire d'origine. Cette méthode peut être appelée par l'ID Account Owner avec le rôle notary dans la limite de temps spécifiée ou par le payeur, le bénéficiaire ou le notaire après la limite de temps spécifiée.

func (t *Controller) ReleaseHoldTokens(token_id string, operation_id string) (interface{} error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.ReleaseHold(operation_id, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
operation_id string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.

Retourne :

En cas de succès, un message indiquant que le blocage a été annulé.

Exemple de valeur renvoyée :

{"msg":"Successfully released '3' tokens from Operation Id 'op2' to Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1)"}

GetOnHoldIds

Cette méthode retourne une liste de tous les ID blocage pour un compte spécifié. Cette méthode peut être appelée par Token Admin du code de chaîne, par Org Admin de l'organisation spécifiée ou par Account Owner du compte.

func (t *Controller) GetOnHoldIds(token_id string, org_id string, user_id string) (interface{}, error) {
      account_id, err := t.Ctx.Account.GenerateAccountId(token_id, org_id, user_id)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.Auth.CheckAuthorization("Account.GetOnHoldIds", "TOKEN", map[string]string{"account_id": account_id})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.Account.GetOnHoldIDs(account_id)
}

Paramètres :

token_id string - ID du jeton.
org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, liste JSON des ID de maintien. Un ID blocage est une concaténation du type de ressource ohold, du nom du jeton, de l'ID jeton et de l'ID opération.

Exemple de valeur renvoyée :

{"holding_ids":["ohold~loyaltok123~t1~op1"],"msg":"Holding Ids are: [ohold~loyaltok123~t1~op1]"}

GetOnHoldDetailsWithOperationId

Cette méthode retourne les détails de la transaction bloquée pour un ID opération et un jeton spécifiés. Cette méthode peut être appelée par n'importe qui.

func (t *Controller) GetOnHoldDetailsWithOperationId(token_id string, operation_id string) (interface{} error) {
    return t.Ctx.Hold.GetOnHoldDetailsWithOperationId(token_id, operation_id)
}

Paramètres :

token_id string - ID du jeton.
operation_id string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.

Retourne :

En cas de succès, un objet de blocage JSON comprenant les propriétés suivantes :
HoldingId - ID détention de la transaction.
OperationId - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
FromAccountId - ID compte du responsable courant des jetons bloqués.
ToAccountId - ID compte du destinataire.
NotaryAccountId - ID compte du notaire.
TokenId - ID du jeton enregistré.
Quantity - Nombre de jetons bloqués pour l'ID blocage.
TimeToExpiration - Durée jusqu'à l'expiration du blocage.

Exemple de valeur renvoyée :

{
    "AssetType": "ohold",
    "HoldingId": "ohold~digicur~digiCurr101~op1",
    "OperationId": "op1",
    "TokenName": "digicur",
    "FromAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "ToAccountId": "oaccount~digicur~38848e87296d67c8a90918f78cf55f9c9baab2cdc8c928535471aaa1210c706e",
    "NotaryAccountId": "oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df",
    "TokenId": "digiCurr101",
    "Quantity": 2,
    "TimeToExpiration": "0"
}

GetOnHoldBalanceWithOperationId

Cette méthode retourne le solde de blocage pour un ID opération et un jeton spécifiés. Cette méthode peut être appelée par n'importe qui.

func (t *Controller) GetOnHoldBalanceWithOperationId(token_id string, operation_id string) (interface{} error) {
    return t.Ctx.Hold.GetOnHoldBalanceWithOperationId(token_id, operation_id)
}

Paramètres :

token_id string - ID du jeton.
operation_id string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.

Retourne :

En cas de succès, une chaîne JSON indiquant le solde de blocage.

Exemple de valeur renvoyée :

{
	"holding_balance": 10,
	"msg": "Current Holding Balance of OperationId opr_121 for token digiCurr101 is : 10"
}

Méthodes de gestion du comportement des jetons - Comportement brûlable

BurnTokens

Cette méthode désactive ou grave les jetons du compte de l'appelant de la transaction. L'appelant de cette méthode doit avoir un compte et le rôle de brûleur. La quantité doit être comprise dans les valeurs décimales spécifiées par le paramètre decimal du comportement divisible dans le fichier de spécification. Cette méthode peut être appelée par Account Owner du compte avec le rôle de brûleur.

func (t *Controller) BurnTokens(token_id string, quantity float64) (interface{} error) {
    tokenAssetValue, err := t.getTokenObject(token_id)
    if err != nil {
        return nil, err
    }
    return t.Ctx.Token.Burn(quantity, tokenAssetValue.Interface())
}

Paramètres :

token_id string - ID du jeton.
quantity float64 - Nombre de jetons à brûler.

Retourne :

En cas de succès, un message de réussite avec la quantité de jetons brûlés et l'ID compte.

Exemple de valeur renvoyée :

{"msg":"Successfully burned 1 tokens from account id: oaccount~digicur~38848e87296d67c8a90918f78cf55f9c9baab2cdc8c928535471aaa1210c706e (org_id : Org1MSP, user_id : user2)"}

Méthodes personnalisées

Vous pouvez utiliser les méthodes de la trousse SDK de jeton pour écrire des méthodes personnalisées pour votre application d'affaires.

Assurez-vous de suivre la valeur retournée lorsque vous utilisez les méthodes de trousse SDK de jeton. En outre, pour éviter les doubles dépenses, ne combinez pas plusieurs fonctions asynchrones qui fonctionnent sur les mêmes paires clé-valeur dans la base de données d'état. Utilisez plutôt la méthode BulkTransferTokens pour effectuer plusieurs transferts dans une méthode.

L'exemple suivant montre comment utiliser des méthodes de trousse SDK de jeton dans des méthodes personnalisées. Lorsque la méthode BuyTicket est appelée, elle transfère 20 jetons du compte de l'appelant au compte du vendeur et retourne le message de transaction du transfert.

func (t *Controller) BuyTicket(TokenId string, SellerOrgId string, SellerUserId string) (interface{}, error){
	token, err := t.Ctx.Token.Get(TokenId)
	if err != nil {
		return nil, err
	}
	
	/**
	* The following method t.Ctx.Account.GenerateAccountId(TokenId, SellerOrgId, SellerUserId) generates account id of the seller
	*/
	sellerAccountId, err := t.Ctx.Account.GenerateAccountId(TokenId, SellerOrgId, SellerUserId)
    if err != nil {
		return nil, err
	}   

	/**
	* The following method t.Ctx.Token.Transfer(sellerAccountId, 20, token) transfers the quantity 20 from caller's
	* account & to seller's account.
	*/
    transaction, err := t.Ctx.Token.Transfer(sellerAccountId, 20, token)
    if err != nil {
		return nil, err
	}
    return transaction, nil
}

Méthodes de la trousse SDK de jeton

Gestion du contrôle d'accès
Gestion de la configuration de jeton
Gestion du compte
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement des jetons

Méthodes pour la gestion du contrôle d'accès

La trousse SDK de jeton fournit une fonction de contrôle d'accès. Certaines méthodes ne peuvent être appelées que par Token Admin, Org Admin ou AccountOwner du jeton. Vous pouvez utiliser cette fonction pour vous assurer que les opérations sont effectuées uniquement par les utilisateurs prévus. Tout accès non autorisé entraîne une erreur. Pour utiliser la fonction de contrôle d'accès, importez la classe Authorization à partir du module ../lib/auth.

import { Authorization } from '../lib/auth';

AddAdmin

Cette méthode ajoute un utilisateur en tant que Token Admin du code de chaîne du jeton.

Ctx.AddAdmin(org_id string, user_id string) (interface{}, error)

Paramètres :

user_id - Nom d'utilisateur ou ID courriel de l'utilisateur.
org_id - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.

Retourne :

Lors de la réussite, un message de réussite et des détails pour l'utilisateur Token Admin qui a été ajouté. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"msg":"Successfully added Admin (Org_Id: Org1MSP, User_Id: user2)"}

RemoveAdmin

Cette méthode supprime un utilisateur en tant que Token Admin du code de chaîne du jeton.

Ctx.RemoveAdmin(org_id string, user_id string) (interface{}, error)

Paramètres :

user_id - Nom d'utilisateur ou ID courriel de l'utilisateur.
org_id - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.

Retourne :

En cas de réussite, un message de réussite et des détails pour l'utilisateur Token Admin ont été supprimés. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"msg":"Successfuly removed Admin (Org_Id Org1MSP User_Id user1)"}

GetAllAdmins

Cette méthode retourne une liste de tous les utilisateurs qui sont Token Admin du code de chaîne du jeton.

Ctx.GetAllAdmins() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de réussite, une liste de tous les utilisateurs qui sont Token Admin du code de chaîne du jeton. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

[{"OrgId":"Org1MSP","UserId":"admin"},{"OrgId":"Org1MSP","UserId":"user1"}]

GetAllAdminUsers

Cette méthode retourne une liste de tous les utilisateurs qui sont Token Admin du code de chaîne du jeton.

Ctx.Admin.GetAllAdminUsers() (interface{}, error)

Paramètres :

aucune

Retourne :

Au moment de la réussite, une liste de tous les utilisateurs qui sont Token Admin du code de chaîne du jeton au format map[string]interface{}. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"admins":[{"OrgId":"Org1MSP","UserId":"admin"},{"OrgId":"Org1MSP","UserId":"user1"}]}

CheckAuthorization

Utilisez cette méthode pour ajouter le contrôle d'accès au code de chaîne. De nombreuses méthodes de jeton générées automatiquement utilisent le contrôle d'accès. Le mappage entre le destinataire de la trousse SDK et les méthodes dotées d'un contrôle d'accès est décrit dans le fichier oChainUtil.go. Pour utiliser votre propre contrôle d'accès ou pour désactiver le contrôle d'accès, supprimez le code de contrôle d'accès des méthodes de contrôleur et des méthodes personnalisées générées automatiquement.

var t TokenAccess
      var r RoleAccess
      var a AccountAccess
      var as AccountStatusAccess
      var h HoldAccess
      var ad AdminAccess
      var trx TransactionAccess
      var tc TokenConversionAccess
      var auth AuthAccess

      auth.IsTokenAdmin = []string{"Admin", "MultipleAccountOwner"}

      trx.DeleteHistoricalTransactions = []string{"Admin"}
      ad.AddAdmin = []string{"Admin"}
      ad.RemoveAdmin = []string{"Admin"}
      ad.GetAllAdmins = []string{"Admin", "OrgAdmin"}
      ad.AddOrgAdmin = []string{"Admin", "OrgAdminOrgIdCheck"}
      ad.RemoveOrgAdmin = []string{"Admin", "OrgAdminOrgIdCheck"}
      ad.GetOrgAdmins = []string{"Admin", "OrgAdmin"}
      ad.IsTokenAdmin = []string{"Admin", "MultipleAccountOwner", "OrgAdmin"}
      t.Save = []string{"Admin"}
      t.GetAllTokens = []string{"Admin", "OrgAdmin"}
      t.Update = []string{"Admin"}
      t.GetTokenDecimals = []string{"Admin", "OrgAdmin"}
      t.GetTokensByName = []string{"Admin", "OrgAdmin"}
      t.AddRoleMember = []string{"Admin", "OrgAdminRoleCheck"}
      t.RemoveRoleMember = []string{"Admin", "OrgAdminRoleCheck"}
      t.IsInRole = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      t.GetTotalMintedTokens = []string{"Admin", "OrgAdmin"}
      t.GetNetTokens = []string{"Admin", "OrgAdmin"}
      t.Get = []string{"Admin", "OrgAdmin"}
      t.GetTokenHistory = []string{"Admin", "OrgAdmin"}
      a.CreateAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      a.AssociateToken = []string{"Admin", "OrgAdminAccountIdCheck"}
      a.GetAllAccounts = []string{"Admin"}
      a.GetAllOrgAccounts = []string{"Admin", "OrgAdminOrgIdCheck"}
      a.GetAccount = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.History = []string{"Admin", "AccountOwner"}
      a.GetAccountTransactionHistory = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountTransactionHistoryWithFilters = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetSubTransactionsById = []string{"Admin", "TransactionInvoker"}
      a.GetSubTransactionsByIdWithFilters = []string{"Admin", "TransactionInvoker"}
      a.GetAccountBalance = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountOnHoldBalance = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetOnHoldIds = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountsByUser = []string{"Admin", "OrgAdminOrgIdCheck", "MultipleAccountOwner"}

      as.Get = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      as.ActivateAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      as.SuspendAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      as.DeleteAccount = []string{"Admin", "OrgAdminOrgIdCheck"}

      r.GetAccountsByRole = []string{"Admin"}
      r.GetUsersByRole = []string{"Admin"}
      r.GetOrgAccountsByRole = []string{"Admin", "OrgAdminOrgIdCheck"}
      r.GetOrgUsersByRole = []string{"Admin", "OrgAdminOrgIdCheck"}

      tc.InitializeExchangePoolUser = []string{"Admin"}
      tc.AddConversionRate = []string{"Admin"}
      tc.UpdateConversionRate = []string{"Admin"}
      tc.GetConversionRate = []string{"Admin", "OrgAdmin", "AnyAccountOwner"}
      tc.GetConversionRateHistory = []string{"Admin", "OrgAdmin", "AnyAccountOwner"}
      tc.TokenConversion = []string{"Admin", "AnyAccountOwner"}
      tc.GetExchangePoolUser = []string{"Admin"}

Ctx.Auth.CheckAuthorization(classFuncName string, args ...string) (bool, error)

Paramètres :

classFuncName string - Valeur de mappage entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
args - Argument de variable, où args[0] est la constante TOKEN et args[1] est l'argument account_id, si nécessaire.

Retourne :

Une réponse booléenne et un message d'erreur en cas d'erreur.

IsUserTokenAdmin

Cette méthode retourne la valeur booléenne true si l'appelant de la fonction est Token Admin. Sinon, la méthode retourne false.

Ctx.Auth.IsUserTokenAdmin()  (bool, error)

Paramètres :

user_id - Nom d'utilisateur ou ID courriel de l'utilisateur.
org_id - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.

Retourne :

Une réponse booléenne et un message d'erreur en cas d'erreur.

Exemple de valeur renvoyée :

{"result":false}

AddOrgAdmin

Cette méthode ajoute un utilisateur en tant que Org Admin de l'organisation.

Ctx.Admin.AddOrgAdmin(org_id, user_id) (interface{}, error)

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été ajouté en tant que Org Admin de l'organisation.

Exemple de valeur renvoyée :

{
    "msg": "Successfully added Org Admin (Org_Id: Org1MSP, User_Id: orgAdmin)"
}

RemoveOrgAdmin

Cette méthode supprime un utilisateur en tant que Org Admin d'une organisation.

Ctx.Admin.RemoveOrgAdmin(org_id, user_id) (interface{}, error)

Paramètres :

org_id string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été supprimé en tant que Org Admin de l'organisation.

Exemple de valeur renvoyée :

{
    "msg": "Successfully removed Org Admin (Org_Id Org1MSP User_Id orgAdmin)"
}

GetOrgAdmins

Cette méthode retourne une liste de tous les utilisateurs qui sont des Org Admin d'une organisation.

Ctx.Admin.GetAllOrgAdmins() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de réussite, une liste JSON comprenant des objets OrgId et UserId.

Exemple de valeur renvoyée :

{
    "admins": [
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin"
        },
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin1"
        },
        {
            "OrgId": "Org1MSP",
            "UserId": "orgadmin2"
        }
    ]
}

Méthodes de gestion de la configuration de jeton

GetTokenDecimals

Cette méthode retourne le nombre de décimales disponibles pour un jeton fractionnaire. Si le comportement divisible n'est pas spécifié, la valeur par défaut est 0.

Ctx.Token.GetTokenDecimals(token_id string) (int, error)

Paramètres :

aucune

Retourne :

En cas de succès, les décimales du jeton, dans le type de données numérique. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

GetAllTokens

Cette méthode retourne toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.Token.GetAllTokens()  (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, tableau d'une carte de toutes les ressources de jeton. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

"payload": [
    {
        "key": "t1",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "Currency_name value",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "Token_desc value",
            "Token_id": "t1",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 999,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

GetTokensByName

Cette méthode retourne toutes les ressources de jeton portant le nom spécifié. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.Token.GetTokensByName(token_name string) (interface{}, error)

Paramètres :

token_name string - Nom du jeton, qui correspond à la propriété Token_name du modèle. La valeur est le nom de classe du jeton.

Retourne :

Il retourne un tableau d'un mappage de toutes les ressources de jeton du nom spécifié.

Exemple de valeur renvoyée :

"payload": [
    {
        "key": "t1",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "Currency_name value",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "Token_desc value",
            "Token_id": "t1",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 999,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    },
    {
        "key": "obp2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "holdable",
                "burnable",
                "roles"
            ],
            "Currency_name": "",
            "Divisible": {
                "Decimal": 8
            },
            "Mintable": {
                "Max_mint_quantity": 10000
            },
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter",
                "notary_role_name": "notary"
            },
            "Token_desc": "",
            "Token_id": "obp2",
            "Token_name": "obptok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

Get

Cette méthode retourne un objet de jeton s'il est présent dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin du code de chaîne du jeton.

Ctx.Get(Id string, result ...interface{}) (interface{}, error)

Paramètres :

token_id: string - ID du jeton à retourner.
result - Argument de variable, où le premier argument result[0] est une référence à un objet Token vide du type requis.

Retourne :

En cas de succès, mappage avec les données de ressource de jeton. L'argument de variable result[0] contient les données du jeton. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "Digital Currency equiv of dollar",
    "Token_type": "fungible",
    "Behavior": ["divisible", "mintable", "transferable", "burnable", "holdable", "roles"],
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter",
        "notary_role_name": "notary"
    },
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "Divisible": {
        "Decimal": 1
    },
    "Token_to_currency_ratio": 1,
    "Currency_representation": "DOLLAR"
}

IsTokenType

Cette méthode teste si une ressource de jeton existe pour un ID jeton spécifié.

Ctx.Model.IsTokenType(token_id: string) error

Paramètres :

token_id: string - ID du jeton à vérifier.

Retourne :

Si une ressource de jeton existe avec l'ID spécifié, une erreur nulle est générée. Sinon, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

nil

Save

Cette méthode crée un jeton et enregistre ses propriétés dans la base de données d'état.

Ctx.Token.Save(args ...interface{}) (interface{}, error)

Paramètres :

token_id: string - ID du jeton à retourner.
args - Argument de variable, où le premier argument args[0] est une référence aux données de jeton struct du type requis à ajouter au livre.

Retourne :

Lors de la réussite, un objet interface{} avec des détails sur le jeton qui a été enregistré dans la base de données d'état. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "",
    "Token_type": "fungible",
    "Behavior": ["divisible", "mintable", "transferable", "burnable", "roles"],
    "Roles": {
        "minter_role_name": "minter"
    },
    "Mintable": {
        "Max_mint_quantity": 1000
    },
    "Divisible": {
        "Decimal": 2
    },
    "Currency_name": "",
    "Token_to_currency_ratio": 1
}

Update

Cette méthode met à jour les propriétés du jeton. Une fois qu'une ressource de jeton est créée, vous pouvez uniquement mettre à jour la valeur token_desc et ses propriétés personnalisées.

Ctx.Token.Update(args ...interface{}) (interface{}, error)

Paramètres :

Ressource qui contient une référence aux données de jeton struct du type requis à mettre à jour dans le livre.

Retourne :

En cas de succès, un message de promesse contenant les détails du jeton. En cas d'erreur, un rejet avec un message d'erreur.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Token_id": "digiCurr101",
    "Token_name": "digicur",
    "Token_desc": "Digital Currency equiv of dollar",
    "Token_type": "fungible",
    "Behavior": ["divisible", "mintable", "transferable", "burnable", "roles"],
    "Roles": {
        "minter_role_name": "minter"
    },
    "Mintable": {
        "Max_mint_quantity": 1000
    },
    "Divisible": {
        "Decimal": 2
    },
    "Currency_name": "",
    "Token_to_currency_ratio": 1
}

GetByRange

Cette méthode appelle la méthode getStateByRange de structure en interne. Même si une immobilisation avec le code donné est retournée du grand livre, cette méthode convertit l'immobilisation dans le type d'immobilisation de l'appelant.

Ctx.Token.GetByRange(startId string, endId string, asset ...interface{}) ([]map[string]interface{}, error)

Paramètres :

startId: string - Clé de début de l'intervalle. Cette clé est incluse dans l'intervalle.
endId: string - Clé de fin de l'intervalle. Cette clé est exclue de l'intervalle.
asset[0] - Tranche vide du jeton du type requis. Si la méthode est exécutée avec succès, elle contient le résultat demandé.

Retourne :

Au succès, une tranche de mappages contenant les détails de la ressource de jeton pour les jetons dont la valeur token_id se trouve dans l'intervalle spécifié. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

[{
    "Key": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
    "Record": {
        "AccountId": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "AssetType": "oaccount",
        "Balance": 99,
        "BalanceOnHold": 1,
        "BapAccountVersion": 0,
        "OrgId": "Org1MSP",
        "TokenId": "t1",
        "TokenName": "loyaltok123",
        "UserId": "u1"
    }
}, {
    "Key": "oaccount~loyaltok123~ac30c5ca924a2c7def61acf596d91e0cca70bc8cd233179df4efb2791b56336b",
    "Record": {
        "AccountId": "oaccount~loyaltok123~ac30c5ca924a2c7def61acf596d91e0cca70bc8cd233179df4efb2791b56336b",
        "AssetType": "oaccount",
        "Balance": 0,
        "BalanceOnHold": 0,
        "BapAccountVersion": 0,
        "OrgId": "Org1MSP",
        "TokenId": "t1",
        "TokenName": "loyaltok123",
        "UserId": "u2"
    }
}, {
    "Key": "oaccount~loyaltok123~aef96c40d99e09ef17f9bdda7038e8fbe829a327bae2b4d8d9fcf752190f3ff0",
    "Record": {
        "AccountId": "oaccount~loyaltok123~aef96c40d99e09ef17f9bdda7038e8fbe829a327bae2b4d8d9fcf752190f3ff0",
        "AssetType": "oaccount",
        "Balance": 0,
        "BapAccountVersion": 0,
        "BalanceOnHold": 0,
        "OrgId": "Org1MSP",
        "TokenId": "t1",
        "TokenName": "loyaltok123",
        "UserId": "admin"
    }
}, {
    "Key": "oadmin~Org1MSP~admin",
    "Record": {
        "AssetType": "oadmin",
        "Key": "oadmin~Org1MSP~admin",
        "OrgId": "Org1MSP",
        "UserId": "admin"
    }
}, {
    "Key": "ohold~loyaltok123~t1~op1",
    "Record": {
        "AssetType": "ohold",
        "FromAccountId": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "HoldingId": "ohold~loyaltok123~t1~op1",
        "NotaryAccountId": "oaccount~loyaltok123~ac30c5ca924a2c7def61acf596d91e0cca70bc8cd233179df4efb2791b56336b",
        "OperationId": "op1",
        "Quantity": 1,
        "TimeToExpiration": "0",
        "ToAccountId": "oaccount~loyaltok123~aef96c40d99e09ef17f9bdda7038e8fbe829a327bae2b4d8d9fcf752190f3ff0",
        "TokenId": "t1",
        "TokenName": "loyaltok123"
    }
}, {
    "Key": "ometadata~loyaltok123~t1",
    "Record": {
        "AssetType": "ometadata",
        "Metadata_id": "ometadata~loyaltok123~t1",
        "Token_id": "t1",
        "Token_name": "loyaltok123",
        "Total_minted_amount": 100,
        "Total_supply": 100
    }
}, {
    "Key": "orole~t1~minter~oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
    "Record": {
        "AccountID": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "AssetType": "orole",
        "Key": "orole~t1~minter~oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "RoleName": "minter",
        "TokenId": "t1"
    }
}, {
    "Key": "otransaction~4a774f6493f6521cab9eda96822cb3bb4103c0738ee2dbb9a193b868ace36fa5",
    "Record": {
        "Amount": 100,
        "AssetType": "otransaction",
        "FromAccountId": "",
        "HoldingId": "",
        "NumberOfSubTransactions": 0,
        "Timestamp": "2021-08-25T23:04:42+05:30",
        "ToAccountId": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "TokenId": "t1",
        "TransactionId": "otransaction~4a774f6493f6521cab9eda96822cb3bb4103c0738ee2dbb9a193b868ace36fa5",
        "TransactionType": "MINT"
    }
}, {
    "Key": "otransaction~69f3cefbcb64b73f01a0eadff87169f456873ccebe61ca8da3eef3f465f0c129",
    "Record": {
        "Amount": 1,
        "AssetType": "otransaction",
        "FromAccountId": "oaccount~loyaltok123~a4bd3d8abfb1708198971311df77bb527233bcf9121ff95b0526bc056c4b8974",
        "HoldingId": "ohold~loyaltok123~t1~op1",
        "NumberOfSubTransactions": 0,
        "Timestamp": "2021-08-25T23:06:13+05:30",
        "ToAccountId": "oaccount~loyaltok123~aef96c40d99e09ef17f9bdda7038e8fbe829a327bae2b4d8d9fcf752190f3ff0",
        "TokenId": "t1",
        "TransactionId": "otransaction~69f3cefbcb64b73f01a0eadff87169f456873ccebe61ca8da3eef3f465f0c129",
        "TransactionType": "ONHOLD"
    }
}, {
    "Key": "t1",
    "Record": {
        "AssetType": "otoken",
        "Behavior": ["divisible", "mintable", "transferable", "burnable", "holdable", "roles"],
        "Currency_Name": "a",
        "Divisible": {
            "Decimal": 2
        },
        "Effective_From_Date": "2020-09-09T00:00:00Z",
        "Mintable": {
            "Max_mint_quantity": 10000
        },
        "Roles": {
            "minter_role_name": "minter"
        },
        "Token_To_Currency_Ratio": 1,
        "Token_desc": "",
        "Token_id": "t1",
        "Token_name": "loyaltok123",
        "Token_type": "fungible"
    }
}]

History

Cette méthode retourne l'historique des jetons pour un ID jeton spécifié.

Ctx.Token.History(tokenId string) (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, un tableau JSON représentant l'historique des jetons.

Exemple de valeur renvoyée :

[
    {
        "IsDelete": "false",
        "Timestamp": "2023-09-01T16:46:33Z",
        "TxId": "12333b8a4f63aa9b3a34072efcbd7df546c6d1e7d82a7a9596e899383656d6f7",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "Currency_name1": "",
            "Divisible": {
                "Decimal": 2
            },
            "Mintable": {
                "Max_mint_quantity": 1000
            },
            "Roles": {
                "minter_role_name": "minter"
            },
            "Token_desc": "updated description",
            "Token_id": "token",
            "Token_name": "fiatmoneytok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-09-01T16:04:25Z",
        "TxId": "99702e2dad7554a5ee4716a0d01d3e394cbce39bea8bade265d8911f30ebad0b",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "Currency_name1": "",
            "Divisible": {
                "Decimal": 2
            },
            "Mintable": {
                "Max_mint_quantity": 1000
            },
            "Roles": {
                "minter_role_name": "minter"
            },
            "Token_desc": "",
            "Token_id": "token",
            "Token_name": "fiatmoneytok",
            "Token_to_currency_ratio": 0,
            "Token_type": "fungible",
            "Token_unit": "fractional"
        }
    }
]

Méthodes de gestion des comptes

GenerateAccountId

Cette méthode retourne un ID compte, qui est un jeu de caractères alphanumériques, précédé de oaccount~<token asset name>~ et suivi d'un hachage du nom d'utilisateur ou de l'ID courriel (user_id) du responsable de l'instance ou de l'utilisateur connecté à l'instance, de l'ID fournisseur de services d'appartenance (org_id) de l'utilisateur dans l'organisation de réseau courante et de l'ID jeton unique (token_id).

Ctx.Account.GenerateAccountId(token_id string, org_id string, user_id string) (string, error)

Paramètres :

token_id: string - ID du jeton.
org_id: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Au succès, l'ID compte généré. En cas d'erreur, un rejet avec un message d'erreur.

Exemple de valeur renvoyée :

oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f

CreateAccount

Cette méthode crée un compte pour un utilisateur et un jeton spécifiés. Chaque utilisateur qui a des jetons à tout moment doit avoir un compte. Les comptes font le suivi du solde d'un utilisateur, du solde bloqué et de l'historique des transactions. Un ID compte est un jeu de caractères alphanumériques, précédé de oaccount~<token asset name>~ et suivi d'un hachage du nom d'utilisateur ou de l'ID courriel (user_id) du responsable de l'instance ou de l'utilisateur connecté à l'instance, de l'ID fournisseur de services d'appartenance (org_id) de l'utilisateur dans l'organisation de réseau courante. Cette méthode ne peut être appelée que par la chaîne Token Admin du code de chaîne.

t.Ctx.Account.CreateAccount(org_id string, user_id string, token_type string)

Paramètres :

org_id: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
user_id: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
token_type: string - Type du jeton, qui doit être fungible.

Retourne :

En cas de succès, l'objet de compte qui a été créé. En cas d'erreur, un rejet avec un message d'erreur.

Exemple de valeur renvoyée :

{
 "AssetType":"oaccount",
"AccountId":"oaccount~a73085a385bc96c4a45aa2dff032e7dede82c0664dee5f396b7c5854eeafd4bd",
   "UserId":"user1",
   "OrgId":"Org1MSP",
   "BapAccountVersion": 0,
   "AccountType":"fungible",
   "TokenId":"",
   "TokenName":"",
   "Balance":0,
   "BalanceOnHold":0
}

AssociateToken

Cette méthode associe un jeton fongible à un compte. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

t.Ctx.Account.AssociateToken(account_id, token_id)

Paramètres :

account_id string - ID du compte.
token_id string - ID du jeton.

Retourne :

En cas de succès, un objet JSON du compte mis à jour.

Exemple de valeur renvoyée :

{ 
"AssetType":"oaccount", 
"AccountId":"oaccount~abc74791148b761352b98df58035601b6f5480448ac2b4a3a7eb54bdbebf48eb", 
"BapAccountVersion": 0,
"UserId":"admin", 
"OrgId":"Org1MSP", 
"AccountType":"fungible", 
"TokenId":"token1", 
"TokenName":"loyaltok", 
"Balance":0, 
"BalanceOnHold":0 
}

GetAccountWithStatus

Cette méthode retourne les détails du compte pour un compte spécifié, notamment le statut du compte.

Ctx.Account.GetAccountWithStatus(account_id string) (interface{}, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, les détails du compte demandé. En cas d'erreur, un rejet avec un message d'erreur.

Exemple de valeur renvoyée :

{
  "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
  "AssetType": "oaccount",
  "Balance": 95,
  "BalanceOnHold": 0,
  "BapAccountVersion": 8,
  "OrgId": "appdev",
  "Status": "active",
  "TokenId": "obp1",
  "TokenName": "obptok",
  "TokenType": "fungible",
  "UserId": "idcqa"
}

GetAccount

Cette méthode retourne les détails du compte pour un compte spécifié.

Ctx.Account.GetAccount(account_id string) (Account, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, les détails du compte demandé. En cas d'erreur, un rejet avec un message d'erreur.

Exemple de valeur renvoyée :

{
    "AssetType": "oaccount",
    "BapAccountVersion": 0,
    "AccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "UserId": "user1",
    "OrgId": "Org1MSP",
    "TokenId": "digiCurr101",
    "TokenName": "digicur",
    "Balance": 0,
    "BalanceOnHold": 0
}

GetAccountHistory

Cette méthode retourne un tableau des détails de l'historique du compte pour un compte spécifié.

Ctx.Account.History(account_id string) ([]interface{}, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, un tableau map[string]interface{} contenant les détails de l'historique du compte. Les données de compte sont affichées sous la clé Value dans le mappage. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur. La valeur retournée est identique à la méthode "GetAccountHistory".

Exemple de valeur renvoyée :

[
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:31:15Z",
      "TxId": "adde470a63860ec1013bd5c5987e8a506a48942a91b0f39fc8e561374042bd27",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 100,
          "BalanceOnHold": 0,
          "BapAccountVersion": 1,
          "OrgId": "Org1MSP",
          "TokenId": "t1",
          "TokenName": "obptok",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  },
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:30:23Z",
      "TxId": "8fbeda2ba60ba175091faae5ae369247775f2cba45c4d6d1ead6f0b05be84743",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 0,
          "BalanceOnHold": 0,
          "BapAccountVersion": 0,
          "OrgId": "Org1MSP",
          "TokenId": "t1",
          "TokenName": "obptok",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  },
  {
      "IsDelete": "false",
      "Timestamp": "2023-08-28T19:29:54Z",
      "TxId": "19bb296ae71709e91b097ba5d9ebd7f7522095880382fbf5913334a46a6026aa",
      "Value": {
          "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
          "AssetType": "oaccount",
          "Balance": 0,
          "BalanceOnHold": 0,
          "BapAccountVersion": 0,
          "OrgId": "Org1MSP",
          "TokenId": "",
          "TokenName": "",
          "TokenType": "fungible",
          "UserId": "idcqa"
      }
  }
]

GetAccountOnHoldBalance

Cette méthode retourne le solde bloqué pour un compte spécifié.

Ctx.Account.getAccountOnHoldBalance(account_id: string)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, un objet de promesse avec le solde de blocage courant et un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
   "holding_balance":0,
   "msg":"Total Holding Balance of Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id: Org1MSP, user_id: user1) is 0"
}

GetAllAccounts

Cette méthode retourne une liste de tous les comptes. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.func (t *Controller) GetAllAccounts() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, un tableau JSON répertorie tous les comptes.

Exemple de valeur renvoyée :

"payload": [
    {
        "key": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
        "valueJson": {
            "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
            "AssetType": "oaccount",
            "Balance": 100,
            "BalanceOnHold": 0,
            "BapAccountVersion": 1,
            "OrgId": "appdev",
            "TokenId": "t1",
            "TokenName": "obptok",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    }
]

GetUserByAccountId

Cette méthode retourne les détails de l'utilisateur pour un compte spécifié.

Ctx.Account.GetUserByAccountById(account_id string) (interface{}, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, une promesse avec un objet JSON comprenant trois propriétés :
- user_id - Nom d'utilisateur ou ID courriel de l'utilisateur.
- org_id - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.
- token_id - ID du jeton.
En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
   "org_id":"Org1MSP",
   "token_id":"digiCurr101",
   "user_id":"user1"
}

GetAccountBalance

Cette méthode retourne le solde du compte pour un compte spécifié.

Ctx.GetAccountBalance(token_id string, org_id string, user_id string) (interface{}, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

En cas de succès, une interface avec une chaîne de message et le solde courant. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "msg": "Current Balance of +p2uaMTsU9D74l9XpHQ2c55ic/2gbO4NZITC4Zq4P8E= is: 200",
    "user_balance": 200
}

GetAllOrgAccounts

Cette méthode retourne une liste de tous les comptes de jeton appartenant à une organisation spécifiée.

Ctx.Account.GetAllOrgAccounts(org_id string) (interface{}, error)

Paramètres :

org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

En cas de succès, une liste de tous les comptes pour l'organisation spécifiée.

Exemple de valeur renvoyée :

[
    {
        "key": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
        "valueJson": {
            "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
            "AssetType": "oaccount",
            "Balance": 0,
            "BalanceOnHold": 0,
            "BapAccountVersion": 0,
            "OrgId": "appdev",
            "TokenId": "token",
            "TokenName": "fiatmoneytok",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "key": "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850",
        "valueJson": {
            "AccountId": "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850",
            "AssetType": "oaccount",
            "Balance": 0,
            "BalanceOnHold": 0,
            "BapAccountVersion": 0,
            "OrgId": "appdev",
            "TokenId": "token",
            "TokenName": "fiatmoneytok",
            "TokenType": "fungible",
            "UserId": "example_minter"
        }
    }
]

Méthodes pour la gestion des rôles

AddRoleMember

Cette méthode ajoute un rôle à un utilisateur et à un jeton spécifiés.

Ctx.Token.AddRoleMember(role string, account_id string, tokenAsset interface{}) (interface{}, error)

Paramètres :

role: string - Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification. De même, le rôle notary correspond à la propriété notary_role_name du fichier de spécification.
account_id: number - ID compte auquel ajouter le rôle.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, il retourne une carte avec un message de réussite indiquant l'ajout du rôle au compte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
   "msg":"Successfully added role minter to oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1)"
}

RemoveRoleMember

Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés.

Ctx.Token.RemoveRoleMember(role string, account_id string, tokenAsset interface{}) (interface{}, error)

Paramètres :

role: string - Nom du rôle à supprimer pour l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification. De même, le rôle notary correspond à la propriété notary_role_name du fichier de spécification.
account_id: number - ID compte duquel supprimer le rôle.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, il retourne une carte avec un message de réussite indiquant la suppression du rôle du compte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
  "msg":"successfully removed member_id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) from role minter"
}

GetAccountsByRole

Cette méthode retourne une liste de tous les comptes pour un rôle et un jeton spécifiés.

Ctx.Role.GetAccountsByRole(token_id string, user_role string) (interface{}, error)

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'ID compte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"accounts":["oaccount~obptok~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f"]}

GetUsersByRole

Cette méthode retourne une liste de tous les utilisateurs pour un rôle et un jeton spécifiés.

Ctx.Role.GetUsersByRole(token_id string, user_role string) (interface{}, error)

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'objets utilisateur. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "Users": [
        {
            "token_id":"digiCurr101",
            "user_id": "user1",
            "org_id": "Org1MSP"
        }
    ]
}

IsInRole

Cette méthode indique si un utilisateur et un jeton ont un rôle spécifié.

Ctx.Token.IsInRole(role string, account_id string, tokenAsset interface{}) (bool, error)

Paramètres :

role: string - Nom du rôle à vérifier.
account_id: number - ID compte à vérifier.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, il retourne une carte avec un message de réussite indiquant la suppression du rôle du compte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "result": false
}

RoleCheck

Cette méthode vérifie si l'ID compte fourni est membre d'un rôle.

Ctx.Token.RoleCheck(account_id string, tokenAsset interface{}) (bool, error)

Paramètres :

account_id: string - ID compte à vérifier.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

Si le compte spécifié a un rôle, un message de réussite et la valeur booléenne Vrai. Sinon, la valeur booléenne faux. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{ result: true }

GetOrgUsersByRole

Cette méthode retourne des informations sur tous les utilisateurs qui ont un rôle spécifié dans une organisation spécifiée.

Ctx.Role.GetOrgUsersByRole(token_id string, user_role string, org_id string) (interface{}, error)

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à vérifier.
org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

Au succès, une liste de tous les utilisateurs ayant le rôle spécifié dans l'organisation spécifiée.

Exemple de valeur renvoyée :

{
    "Users": [
        {
            "org_id": "Org1MSP",
            "token_id": "token",
            "user_id": "admin"
        },
        {
            "org_id": "Org1MSP",
            "token_id": "token",
            "user_id": "orgAdmin"
        }
    ]
}

GetOrgAccountsByRole

Cette méthode retourne des informations sur tous les comptes qui ont un rôle spécifié dans une organisation spécifiée.

Ctx.Role.GetOrgAccountsByRole(token_id string, user_role string, org_id string) (interface{}, error)

Paramètres :

token_id: string - ID du jeton.
role: string - Nom du rôle à vérifier.
org_id: string - ID fournisseur de services d'adhésion (MSP) de l'organisation.

Retourne :

En cas de succès, une liste de tous les comptes ayant le rôle spécifié dans l'organisation spécifiée.

Exemple de valeur renvoyée :

{
    "accounts": [
        "oaccount~abc74791148b761352b98df58035601b6f5480448ac2b4a3a7eb54bdbebf48eb",
         "oaccount~9c650574af9025a6106c8d12a801b079eda9ae2e3399fc2fbd5bd683d738a850"
    ]
}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

Cette méthode retourne un tableau des détails de l'historique des transactions pour un compte spécifié.

Ctx.Account.GetAccountTransactionHistory(account_id string) (interface{}, error)

Paramètres :

account_id: string - ID du compte.

Retourne :

La valeur retournée est identique à la méthode "GetAccountTransactionHistory".
En cas de succès, un tableau d'objets de transaction de compte JSON.
En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

[
  {
      "NumberOfSubTransactions": 2,
      "balance": 160,
      "onhold_balance": 0,
      "timestamp": "2023-09-06T06:51:48Z",
      "token_id": "t1",
      "transacted_amount": 20,
      "transaction_id": "otransaction~bd3e8d7d0bcdbed0469a2fccfe95f7ebbeb1987d8385bccf5c84bf80251e748c",
      "transaction_type": "BULKTRANSFER"
  },
  {
      "balance": 180,
      "onhold_balance": 0,
      "timestamp": "2023-09-06T06:47:14Z",
      "token_id": "t1",
      "transacted_account": "oaccount~692a7465c01e36b694cb8ae86e6c6584240aa1f865fde54f95f32429eadd4097",
      "transacted_amount": 10,
      "transaction_id": "otransaction~250996f1df6a36a1b647f522efcaaf48fd70452d711c247fc4cd475b8e752b08",
      "transaction_type": "DEBIT"
  },
  {
      "balance": 190,
      "onhold_balance": 0,
      "timestamp": "2023-09-06T06:47:08Z",
      "token_id": "t1",
      "transacted_account": "oaccount~bb5a0b57d895327c8a8cd1f267310cbf3ae542bc854fab8188b5083a969d72fb",
      "transacted_amount": 10,
      "transaction_id": "otransaction~664325a25ae6b19b23693c66f83811184e0a78fabb49122359a2dbf209f32976",
      "transaction_type": "DEBIT"
  },
  {
      "balance": 200,
      "onhold_balance": 0,
      "timestamp": "2023-09-06T06:46:46Z",
      "token_id": "t1",
      "transacted_account": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
      "transacted_amount": 100,
      "transaction_id": "otransaction~7f49564b1eb61d4c8be0ef61cd5e635b533ca533907944e4ec500f390237fd6b",
      "transaction_type": "MINT"
  },
  {
      "balance": 100,
      "onhold_balance": 0,
      "timestamp": "2023-08-28T19:31:15Z",
      "token_id": "t1",
      "transacted_account": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
      "transacted_amount": 100,
      "transaction_id": "otransaction~adde470a63860ec1013bd5c5987e8a506a48942a91b0f39fc8e561374042bd27",
      "transaction_type": "MINT"
  }
]

GetAccountTransactionHistoryWithFilters

Cette méthode retourne un tableau des détails de l'historique des transactions pour une transaction spécifiée. Cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau distant Oracle Blockchain Platform.

t.Ctx.Account.GetAccountTransactionHistoryWithFilters (transaction_id: string, filters?: SubTransactionFilters)

Paramètres :

Transaction_id: string - ID de la transaction.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Exemple :

ochain invoke GetAccountTransactionHistoryWithFilters 'token1' 'appbuilder12' 'user_minter' '{"PageSize":10,"Bookmark":"1","StartTime":"2022-01-25T17:41:42Z","EndTime":"2022-01-25T17:59:10Z"}'

[
    {
        "balance": 90,
        "onhold_balance": 0,
        "timestamp": "2022-04-20T19:43:36Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~7a4d67118e623a876b77c67e76b819269a8d4a509aece5d2263fb274a9beb3b8",
        "transacted_amount": 5,
        "transaction_id": "otransaction~dd9986d3686e52264935558e42026fbf8a9af48b06a3256a58b453f5ada4e636",
        "transaction_type": "DEBIT"
    },
    {
        "balance": 95,
        "onhold_balance": 0,
        "timestamp": "2022-04-20T19:43:22Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~0642308fc4c514c257ebf04326c63f990e2531bfd59d0b952056094da61e04ab",
        "transacted_amount": 5,
        "transaction_id": "otransaction~5e53424de3d691cf6b2a55ea3dc478c555d8784111c11847e594194d6c2e7755",
        "transaction_type": "DEBIT"
    },
    {
        "balance": 100,
        "onhold_balance": 0,
        "timestamp": "2022-04-20T19:42:54Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~b63935592a702d30bedb87ae97b9b1ba7d0f346716adc4f5a4192220bf410d4e",
        "transacted_amount": 100,
        "transaction_id": "otransaction~94c467825ce9f66cc69958d38b169022a69eebc66b75b7d6e0b0585af2c3c228",
        "transaction_type": "MINT"
    }
]

GetSubTransactionsById

Cette méthode retourne un tableau des détails de l'historique des transactions pour une transaction spécifiée.

t.Ctx.Account.GetSubTransactionsById(transaction_id string)

Paramètres :

transaction_id: string - ID de la transaction.

Exemple :

ochain invoke GetSubTransactionsById 'otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b'

[
    {
        "balance": 80,
        "onhold_balance": 0,
        "timestamp": "2022-04-21T05:02:33Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~7a4d67118e623a876b77c67e76b819269a8d4a509aece5d2263fb274a9beb3b8",
        "transacted_amount": 5,
        "transaction_id": "otransaction~33de5d63058d5e9abc011bc850878dfb7ac3080495729aed345c45b2f21735fa~c81e728d9d4c2f636f067f89cc14862c",
        "transaction_type": "DEBIT"
    },
    {
        "balance": 85,
        "onhold_balance": 0,
        "timestamp": "2022-04-21T05:02:33Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~0642308fc4c514c257ebf04326c63f990e2531bfd59d0b952056094da61e04ab",
        "transacted_amount": 5,
        "transaction_id": "otransaction~33de5d63058d5e9abc011bc850878dfb7ac3080495729aed345c45b2f21735fa~c4ca4238a0b923820dcc509a6f75849b",
        "transaction_type": "DEBIT"
    }
]

GetSubTransactionsByIdWithFilters

Cette méthode retourne un tableau des détails de l'historique des transactions pour une transaction spécifiée.

t.Ctx.Account.GetSubTransactionsByIdWithFilters(transaction_id string, filters ...SubTransactionFilters)

Paramètres :

transaction_id: string - ID de la transaction.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Exemple :

ochain invoke GetSubTransactionsByIdWithFilters 'otransaction~21972b4d206bd52ea77924efb259c67217edb23b4386580d1bee696f6f864b9b' '{"PageSize":10,"Bookmark":"1"}'

[
    {
        "balance": 80,
        "onhold_balance": 0,
        "timestamp": "2022-04-21T05:02:33Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~7a4d67118e623a876b77c67e76b819269a8d4a509aece5d2263fb274a9beb3b8",
        "transacted_amount": 5,
        "transaction_id": "otransaction~33de5d63058d5e9abc011bc850878dfb7ac3080495729aed345c45b2f21735fa~c81e728d9d4c2f636f067f89cc14862c",
        "transaction_type": "DEBIT"
    },
    {
        "balance": 85,
        "onhold_balance": 0,
        "timestamp": "2022-04-21T05:02:33Z",
        "token_id": "tokenId",
        "transacted_account": "oaccount~0642308fc4c514c257ebf04326c63f990e2531bfd59d0b952056094da61e04ab",
        "transacted_amount": 5,
        "transaction_id": "otransaction~33de5d63058d5e9abc011bc850878dfb7ac3080495729aed345c45b2f21735fa~c4ca4238a0b923820dcc509a6f75849b",
        "transaction_type": "DEBIT"
    }
]

GetTransactionById

Cette méthode retourne l'historique d'une ressource Transaction.

t.Ctx.Transaction.GetTransactionById(transaction_id string)

Paramètres :

transaction_id string - ID de l'immobilisation de transaction.

Exemple de valeur renvoyée :

{
    "history": [
        {
            "IsDelete": "false",
            "Timestamp": "2021-08-16 20:19:05.028 +0530 IST",
            "TxId": "67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220",
            "Value": {
                "Amount": 3,
                "AssetType": "otransaction",
                "FromAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
                "HoldingId": "ohold~digicur~digiCurr101~op2",
                "NumberOfSubTransactions": 0,
                "Timestamp": "2021-08-16T20:19:05+05:30",
                "ToAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
                "TokenId": "digiCurr101",
                "TransactionId": "otransaction~67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220",
                "TransactionType": "RELEASEHOLD"
            }
        }
    ],
    "transaction_id": "otransaction~67042154a6853011d111b13f73943f06d2a6ae3cfb9a84cb104482c359eb2220"
}

DeleteHistoricalTransactions

Cette méthode supprime les anciennes transactions de la base de données d'état.

func (t *Controller) DeleteHistoricalTransactions(timestamp string) (interface{}, error)

Paramètres :

time_to_expiration: Date - Horodatage qui indique quand supprimer des transactions. Les immobilisations de transaction antérieures à l'heure spécifiée seront supprimées.

Exemple de valeur renvoyée :

"payload": {
    "msg": "Successfuly deleted transaction older than date:2021-08-18T05:43:30Z",
    "transactions": [
        "otransaction~57d81f681aa215bb73d6c017d16be8b283d3fcb50051c85891a97d1d407fc342"
    ]
}

Méthodes de gestion du comportement des jetons - Comportement mintable

Mint

Ctx.Token.Mint(quantity float64, tokenAsset interface{}) (interface{}, error)

Paramètres :

quantity: number - Nombre de jetons à menthe.
tokenAsset - Référence à la ressource de jeton à ment.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
  "msg":"Successfully minted 1000 tokens to Account Id: oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df (Org-Id: Org1MSP, User-Id: admin)"
}

GetTotalMintedTokens

Cette méthode retourne le nombre total de jetons frappés.

Ctx.Token.GetTotalMintedTokens(tokenAsset interface{}) (map[string]interface{}, error)

Paramètres :

tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, un message de réussite et une carte du nombre total de jetons frappés dans le type de données Nombre. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"msg":"total minted amount for token with id digiCurr101 is 0","quantity":0}

GetNetTokens

Cette méthode retourne la quantité nette de jetons disponibles dans le système pour un jeton spécifié. Les jetons nets sont la quantité de jetons restants après la combustion des jetons. Sous forme d'équation : jetons nets = jetons totaux frappés - jetons totaux brûlés. Si aucun jeton n'est brûlé, le nombre de jetons nets est égal au nombre total de jetons frappés.

Ctx.Token.GetNetTokens(tokenAsset interface{}) (map[string]interface{}, error)

Paramètres :

tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, un message de réussite et une carte de la quantité nette de jetons dans le type de données numérique. En cas d'erreur, un message d'erreur s'affiche.

Exemple de valeur renvoyée :

{"msg":"net minted amount for token with id digiCurr101 is 0","quantity":0}

GetMaxMintQuantity

Cette méthode retourne la quantité minimale maximale pour un jeton. Si le comportement max_mint_quantity n'est pas spécifié, la valeur par défaut est 0, ce qui permet de frapper un nombre quelconque de jetons.

Ctx.Token.GetMaxMintQuantity(token_id string) (float64, error)

Paramètres :

token_id: string - ID jeton à vérifier.

Retourne :

En cas de succès, quantité minimale maximale du jeton, dans le type de données numérique. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

Méthodes de gestion du comportement des jetons - Comportement transférable

Transfer

Ctx.Token.Transfer(to_account_id string, quantity float64, tokenAsset interface{}) (interface{}, error)

Paramètres :

to_account_id: string - ID compte pour la réception des jetons.
quantity: number - Nombre total de jetons à transférer.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur. La valeur retournée est identique à la méthode "TransferTokens".

Exemple de valeur renvoyée :

{     "msg":"Successfully transferred 50 tokens from account id: oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df (Org-Id: Org1MSP,  User-Id: admin) to account id: oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (Org-Id: Org1MSP, User-Id: user1)"
}

BulkTransfer

Cette méthode est utilisée pour effectuer un transfert en masse de jetons du compte de l'appelant vers les comptes spécifiés dans l'objet flow. Un compte doit déjà être créé pour l'appelant de cette méthode.

Ctx.Token.BulkTransfer(flow []map[string]interface{}, tokenAsset interface{}) (interface{}, error)

Paramètres :

flow: object[] - Tableau d'objets JSON spécifiant les détails et la quantité du destinataire. La quantité de transfert doit être comprise dans les valeurs décimales spécifiées par le paramètre decimal du comportement divisible dans le fichier de spécification. Par exemple :
```
[{
	"to_org_id": "Org1MSP",
	"to_user_id": "user1",
	"quantity": 10
}, {
	"to_org_id": "Org1MSP",
	"to_user_id": "user2",
	"quantity": 10
}]
```
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de succès, un message de réussite comprenant le nombre de jetons transférés. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "from_account_id": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "msg": "Successfully transferred 2 tokens from Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (Org-Id: Org1MSP, User-Id: user1)",
    "sub_transactions": [
        {
            "amount": 1,
            "to_account_id": "oaccount~digicur~38848e87296d67c8a90918f78cf55f9c9baab2cdc8c928535471aaa1210c706e"
        },
        {
            "amount": 1,
            "to_account_id": "oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df"
        }
    ]
}

Méthodes de gestion du comportement des jetons - Comportement bloquable

Hold

Ctx.Token.Hold(operation_id string, to_account_id string, notary_account_id string, quantity float64, TimeToExpiration string, tokenAsset)) (interface{}, error)

Paramètres :

operation_id: string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
to_account_id: string - ID du compte pour la réception des jetons.
notary__account_id: string - ID du compte de notaire.
quantity: number - Nombre total de jetons à mettre en attente.
time_to_expiration: date - Durée jusqu'à l'expiration du blocage. Spécifiez 0 pour un blocage permanent. Sinon, utilisez le format RFC-3339. Par exemple, 2021-06-02T12.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
 "msg": "account id: oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df (org_id : Org1MSP, user_id : user1) is successfully holding 10 tokens",
}

ExecuteHold

Cette méthode effectue un blocage sur les jetons, en transférant la quantité spécifiée de jetons précédemment bloqués au destinataire. Si la valeur quantity est inférieure à la valeur de blocage réelle, le montant restant est de nouveau disponible pour le responsable initial des jetons. Cette méthode ne peut être appelée que par l'ID AccountOwner doté du rôle notary.

Ctx.Token.ExecuteHold(operation_id string, quantity float64, tokenAsset interface{}) (interface{}, error)

Paramètres :

operation_id: string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
quantity: number - Nombre total de jetons à mettre en attente.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"msg":"Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1) has successfully executed '1' tokens(digiCurr101) from the hold with Operation Id 'op1'"}

ReleaseHold

Ctx.Token.ReleaseHold(operation_id string, tokenAsset interface{}) (interface{}, error)

Paramètres :

operation_id: string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{"msg":"Successfully released '3' tokens from Operation Id 'op2' to Account Id oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f (org_id : Org1MSP, user_id : user1)"}

GetOnHoldIds

Cette méthode retourne une liste de tous les ID de blocage pour un utilisateur et un jeton spécifiés.

Ctx.Account.GetOnHoldIDs(account_id string) (map[string]interface{}, error)

Paramètres :

token_id - ID du jeton.
org_id - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.
user_id - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un objet JSON avec la liste des ID de maintien. Un ID blocage est formé en concaténant le type de ressource (ohold), le nom du jeton, l'ID jeton et l'ID opération.

Exemple de valeur renvoyée :

{"holding_ids":["ohold~loyaltok123~t1~op1"],"msg":"Holding Ids are: [ohold~loyaltok123~t1~op1]"}

GetOnHoldDetailsWithOperationID

Cette méthode retourne les détails de la transaction bloquée pour un ID opération et un jeton spécifiés.

Ctx.Hold.GetOnHoldDetailsWithOperationID(token_id string, operation_id string) (Hold, error)

Paramètres :

token_id: string - ID du jeton.
operation_id: string - ID unique qui identifie l'opération de blocage. En général, cet ID est transmis par l'application client.

Retourne :

La valeur retournée est identique à la méthode "GetOnHoldDetailsWithOperationId".
En cas de succès, un objet de promesse qui inclut les détails de transaction bloquée pour l'ID opération et le jeton spécifiés. L'objet de blocage inclut les propriétés suivantes :
- holding_id - ID détention de la transaction.
- operation_id: string - ID unique identifiant l'opération de blocage. En général, cet ID est transmis par l'application client.
- from_account_id - ID compte du responsable courant des jetons bloqués.
- to_account_id - ID compte du destinataire.
- notary_account_id - ID compte du notaire.
- token_id: string - ID du jeton enregistré.
- quantity - Nombre de jetons bloqués pour l'ID blocage.
- time_to_expiration - Durée jusqu'à l'expiration du blocage.
En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "AssetType": "ohold",
    "HoldingId": "ohold~digicur~digiCurr101~op1",
    "OperationId": "op1",
    "TokenName": "digicur",
    "FromAccountId": "oaccount~digicur~b4f45440aa2a7942db64443d047027e9d714d62cba5c3d546d64f368642f622f",
    "ToAccountId": "oaccount~digicur~38848e87296d67c8a90918f78cf55f9c9baab2cdc8c928535471aaa1210c706e",
    "NotaryAccountId": "oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df",
    "TokenId": "digiCurr101",
    "Quantity": 2,
    "TimeToExpiration": "0"
}

GetOnHoldBalanceWithOperationID

Cette méthode retourne le solde de blocage pour un ID opération et un jeton spécifiés.

Ctx.Hold.GetOnHoldBalanceWithOperationID(token_id string, operation_id string) (map[string]interface{}, error)

Paramètres :

token_id: string - ID du jeton.
operation_id: string - ID unique qui identifie l'opération de blocage. En général, cet ID est transmis par l'application client.

Retourne :

Lors du succès, le solde bloqué de l'ID opération et du jeton spécifiés. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
    "holding_balance": 10,
    "msg": "Current Holding Balance of OperationId opr_121 for token digiCurr101 is : 10"
}

Méthodes de gestion du comportement des jetons - Comportement brûlable

Burn

Ctx.Token.Burn(quantity float64 , tokenAsset interface{}) (interface{}, error)

Paramètres :

quantity: number - Nombre total de jetons à brûler.
tokenAsset - L'argument tokenAsset contient la référence des données de jeton sur lesquelles opérer.

Retourne :

En cas de réussite, un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple de valeur renvoyée :

{
 "msg":"Successfully burned 10 tokens from account id: oaccount~digicur~682bb71de419602af74e3f226345ae308445ca51010737900c1d85f0376152df (Org-Id: Org1MSP, User-Id: admin)"
}