Chaincode-Ereignisse

Die erweiterte Version von Blockchain App Builder kann Chaincodeereignisse für Tokenvorgänge generieren.

Chaincode-Ereignisse sind spezifische Benachrichtigungen, die bei der Ausführung von Transaktionen ausgegeben werden. Ereignisse umfassen Transaktionsinformationen, mit denen externe Systeme über bestimmte Bedingungen oder Änderungen im Blockchain-Ledgerstatus benachrichtigt werden können. Sie können Chaincode-Ereignisse verwenden, um die Echtzeitintegration und -interaktion mit Anwendungen zu ermöglichen, die sich nicht in der Blockchain befinden, und um ereignisgesteuerte Workflows und die Überwachung in der gesamten Blockchain-Umgebung zu erleichtern. Chaincode-Ereignisse haben zwei Komponenten: den Ereignisnamen und die Payload.

Chaincode-Ereignisse werden für alle Blockchain App Builder-Spezifikationsdateien unterstützt. Wenn Sie Chaincode-Ereignisse aktivieren, geben alle Controllerfunktionen in Ihrem gerüsteten Projekt Ereignisse aus, mit Ausnahme von Getter-Methoden. Beispiel: In einem Tokenszenario werden Chaincode-Ereignisse ausgegeben, wenn Token geprägt, übertragen, gebrannt oder gesperrt werden

Sie verwenden den booleschen Parameter events in der Spezifikationsdatei, um Chaincode-Ereignisse zu aktivieren, wie im folgenden Beispiel dargestellt.

assets:
    - name: FiatMoneyTOK # Asset name
      type: token  # Asset type
      events: true  # Generate events for create, update and delete APIs

Wenn Sie Ereignisse aktivieren, enthält der Controller in Ihrem gerüsteten Chaincode-Projekt Ereigniserstellungsmethoden, wie in den folgenden Beispielen dargestellt.

TypeScript:

@Validator(yup.string(), yup.string(), yup.string())
public async createAccount(org_id: string, user_id: string, token_type: string) {
  await this.Ctx.Auth.checkAuthorization("ACCOUNT.createAccount", "TOKEN", { org_id });
  await this.Ctx.Model.createEvent(EVENT_NAME.CREATE_ACCOUNT, { org_id, user_id, token_type });
  return await this.Ctx.Account.createAccount(org_id, user_id, token_type);
}

Start:

func (t *Controller) CreateAccount(org_id string, user_id string, token_type string, daily_limits ...account.AccountDailyLimits) (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())
    }
    err = t.Ctx.Model.CreateEvent(constants.CreateAccountEventName, map[string]interface{}{"org_id": org_id, "user_id": user_id, "token_type": token_type})
    if err != nil {
        return nil, err
    }
    return t.Ctx.Account.CreateAccount(org_id, user_id, token_type, daily_limits...)
}

Chaincode-Ereignisse verwenden die folgenden Standardwerte für den Namen und die Payload-Komponenten. Sie können die Standardwerte nach Bedarf ändern.

EventName
Der Name der Controller-Funktion.
Payload
Ein JSON-Objekt, das alle Eingabeparameter der Controllerfunktion enthält.
Ein neuer Parameter events wurde auch zu den Tokendetails in den erweiterten Token Taxonomy Framework- und ERC-1155-Standards hinzugefügt. Wenn der Parameter events in der Spezifikationsdatei auf "true" gesetzt ist, wird der Parameter events im generierten Token auf "true" gesetzt. Wenn der Parameter events in der Spezifikationsdatei auf "false" oder nicht definiert ist, wird der Parameter events im generierten Token auf "false" gesetzt. Die folgenden Beispiele zeigen ein Token mit dem neuen Parameter events für TypeScript und Go.
{
    "metadata": {
        "paintingName": "monalisa",
        "description": "monalisa painting",
        "image": "image link",
        "painterName": "Leonardo da Vinci"
    },
    "assetType": "otoken",
    "events": true,
    "quantity": 1,
    "tokenId": "artnft",
    "tokenName": "artcollection",
    "tokenDesc": "artcollection nft",
    "tokenStandard": "erc1155+",
    "tokenType": "nonfungible",
    "tokenUnit": "whole",
    "behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "roles": {
        "minter_role_name": "minter",
        "burner_role_name": "burner"
    },
    "mintable": {
        "max_mint_quantity": 500
    },
    "owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "createdBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "creationDate": "2022-12-29T04:08:35.000Z",
    "isBurned": false,
    "tokenUri": "tu",
    "price": 10000,
    "onSaleFlag": false
}
{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-12-29T09:57:03+05:30",
    "Events": true,
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 500
    },
    "OnSaleFlag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 100,
    "Quantity": 1,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "token description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}

Ereignisse generieren

Mit der Methode stub.setEvent kann der Chaincode ein Ereignis erstellen und ausgeben, wenn eine Transaktion ausgeführt wird. Der folgende Code zeigt die TypeScript-Version der Methode.
async setEvent(eventName: string, payload: Buffer): Promise<void>

In diesem Beispiel ist eventName der Name, der dem Ereignis zugewiesen werden soll, und payload sind Daten, die mit dem Ereignis verknüpft sind. Die Payload kann alle Informationen enthalten, die Sie mit dem Ereignis senden möchten, im Allgemeinen im JSON-Format serialisiert.

Chaincode-Ereignisse für Batchmethoden

Der erweiterte ERC-1155-Standard unterstützt Batch-Methoden. Batchmethoden arbeiten mit mehreren Token, die als Parameter übergeben werden. Bei Batchmethoden werden Chaincodeereignisse nur für die Token ausgegeben, bei denen der Parameter events in der Spezifikationsdatei auf true gesetzt ist.

Für jede in der Batch-Methode abgeschlossene Transaktion wird ein entsprechendes Chaincode-Ereignis generiert. Die Payload jedes Chaincode-Ereignisses enthält die Transaktionsdetails. Beispiel: Wenn Sie die Methode BatchTransfer verwenden, um Mengen von fünf verschiedenen Token zu übertragen, werden fünf entsprechende Chaincodeereignisse ausgegeben. Die Payload jedes Ereignisses enthält die Tokendetails und die übertragene Menge sowie allgemeine Parameter, die für alle Batchübertragungen gelten.

Das folgende Beispiel zeigt den Eventcode mit dem erweiterten ERC-1155-Standard.
@Validator(yup.string(), yup.string(), yup.string(), yup.string(), yup.array().of(yup.string()), yup.array().of(yup.number()))
  public async batchTransferFrom(
    fromOrgId: string,
    fromUserId: string,
    toOrgId: string,
    toUserId: string,
    tokenIds: string[],
    quantity: number[]
  ) {
    const fromAccountId = this.Ctx.ERC1155Account.generateAccountId(fromOrgId, fromUserId, ACCOUNT_TYPE.USER_ACCOUNT);
    const toAccountId = this.Ctx.ERC1155Account.generateAccountId(toOrgId, toUserId, ACCOUNT_TYPE.USER_ACCOUNT);
    let tokenAssets = [];
    for (let i = 0; i < tokenIds.length; i++) {
      const tokenAsset = await this.Ctx.ERC1155Token.get(tokenIds[i]);
      tokenAssets.push(tokenAsset);
    }
    await this.Ctx.Model.createEventForBatch(EVENT_NAME.BATCH_TRANSFER_FROM, { fromOrgId, fromUserId, toOrgId, toUserId }, quantity, tokenAssets);
    return await this.Ctx.ERC1155Token.batchTransferFrom(fromAccountId, toAccountId, tokenIds, quantity);
  }

Chaincode-Ereignisse für mehrere Anlagen

Die erweiterten Standards Token Taxonomy Framework und ERC-1155 unterstützen die Definition mehrerer Tokenassets in einer Spezifikationsdatei. Das Verhalten des Chaincode-Ereignisses unterscheidet sich je nachdem, ob eine Methode tokenspezifisch ist (z. B. Erstellen oder Aktualisieren eines Tokens) oder allgemein (z. B. Minting oder Brennen).

Bei tokenspezifischen Methoden werden Chaincode-Ereignisse nur für die Token generiert, bei denen der Parameter events in der Spezifikationsdatei auf true gesetzt ist.

Bei allgemeinen Methoden werden Chaincodeereignisse im gerüsteten Projekt generiert, wenn bei einem Token der Parameter events in der Spezifikationsdatei auf true gesetzt ist. Das tatsächliche Chaincode-Ereignisverhalten basiert auf der Anzahl der an die Methode übergebenen Token-ID-Parameter.

  • Wenn eine einzelne Token-ID als Parameter übergeben wird, werden Chaincode-Ereignisse nur generiert, wenn der Parameter events in den entsprechenden Tokendetails auf "true" gesetzt ist.
  • Wenn mehrere Token-IDs als Parameter übergeben werden, werden Chaincode-Ereignisse nur generiert, wenn der Parameter events in einem der Tokendetails auf "true" gesetzt ist.
  • Wenn keine Token-ID als Parameter übergeben wird, werden Chaincode-Ereignisse immer generiert.
Die folgende Liste zeigt gängige Methoden, die zwei Token übergeben werden müssen. Diese Liste gilt für den erweiterten Token Taxonomy Framework-Standard.
  • addConversionRate(from_token_id: string, to_token_id: string, token_conversion_rate: number)
  • updateConversionRate(from_token_id: string, to_token_id: string, token_conversion_rate: number)
  • tokenConversion(from_token_id: string, to_token_id: string, to_org_id: string, to_user_id: string,token_quantity: number)
  • exchangeToken(fromTokenId: string, fromOrgId: string, fromUserId: string, fromTokenQuantity: number, toTokenId: string, toOrgId: string,toUserId: string,toTokenQuantity: number)
Die folgende Liste zeigt gängige Methoden, die keine Token als Argumente annehmen. Die folgende Liste gilt für den erweiterten Token Taxonomy Framework-Standard.
  • addTokenAdmin(org_id: string, user_id: string)
  • removeTokenAdmin(org_id: string, user_id: string)
  • addOrgAdmin(org_id: string, user_id: string)
  • removeOrgAdmin(org_id: string, user_id: string)
  • createAccount(org_id: string, user_id: string, token_type: string)
  • deleteHistoricalTransactions(time_to_expiration: Date)
  • initializeExchangePoolUser(org_id: string, user_id: string)
Diese Liste zeigt gängige Methoden, die keine Token als Argumente für den erweiterten ERC-1155-Standard verwenden.
  • addTokenAdmin(orgId: string, userId: string)
  • removeTokenAdmin(orgId: string, userId: string)
  • createAccount(orgId: string, userId: string, ftAccount: boolean, nftAccount: boolean)
  • createUserAccount(orgId: string, userId: string)
  • createTokenAccount(orgId: string, userId: string, tokenType: TokenType)
  • addTokenSysRole(orgId: string, userId: string, role: string)
  • removeTokenSysRole(orgId: string, userId: string, role: string)
  • transferTokenSysRole(fromOrgId: string, fromUserId: string, toOrgId: string, toUserId: string, role: string)
  • deleteHistoricalTransactions(time_to_expiration: Date)

TypeScript SDK-Methoden für Chaincode-Ereignisse

createEvent
Diese Methode generiert Ereignisse basierend auf einem angegebenen Ereignisnamen und einer angegebenen Payload.
public async createEvent(eventName: any, eventPayload: any, assets?: any)
Parameter:
  • eventName: string: Der Ereignisname, der beim Generieren von Ereignissen verwendet werden soll.
  • eventPayload: map[string]interface{}: Die Ereignis-Payload, die beim Generieren von Ereignissen verwendet werden soll.
  • assets: Optional kann das Tokenasset als Parameter an die Methode übergeben werden.
createEventForBatch
Diese Methode generiert Ereignisse für Batchvorgänge, wie die Methoden mintBatch oder burnBatch.
public async createEventForBatch(eventName: any, eventPayload: any, quantities: number[], assets: any)
Parameter:
  • eventName: string: Der Ereignisname, der beim Generieren von Ereignissen verwendet werden soll.
  • eventPayload: map[string]interface{}: Die Ereignis-Payload, die beim Generieren von Ereignissen verwendet werden soll.
  • quantities: number[]: Eine Liste der Beträge, die jeder Token-ID entsprechen und die Anzahl der Token darstellen, die in den Transaktionen der Batchmethode verwendet werden sollen.
  • assets: Optional kann das Tokenasset als Parameter an die Methode übergeben werden.

Go SDK-Methoden für Chaincode-Ereignisse

CreateEvent
Diese Methode generiert Ereignisse basierend auf einem angegebenen Ereignisnamen und einer angegebenen Payload.
func (m *Model) CreateEvent(eventName string, eventPayload map[string]interface{}, assets ...interface{})
Parameter:
  • eventName: string: Der Ereignisname, der beim Generieren von Ereignissen verwendet werden soll.
  • eventPayload: map[string]interface{}: Die Ereignis-Payload, die beim Generieren von Ereignissen verwendet werden soll.
  • assets: Optional kann das Tokenasset als Parameter an die Methode übergeben werden.
CreateEventForBatch
Diese Methode generiert Ereignisse für Batchvorgänge, wie die Methoden mintBatch oder burnBatch.
func (m *Model) CreateEventForBatch(eventName string, eventPayload map[string]interface{}, quantities []float64, assets []interface{})
Parameter:
  • eventName: string: Der Ereignisname, der beim Generieren von Ereignissen verwendet werden soll.
  • eventPayload: map[string]interface{}: Die Ereignis-Payload, die beim Generieren von Ereignissen verwendet werden soll.
  • quantities: []float64: Eine Liste der Beträge, die jeder Token-ID entsprechen und die Anzahl der Token darstellen, die in den Transaktionen der Batchmethode verwendet werden sollen.
  • assets: Optional kann das Tokenasset als Parameter an die Methode übergeben werden.

Ereignisgenerierung in Blockchain App Builder Chaincode

Wenn der Parameter events in der Spezifikationsdatei auf "true" gesetzt ist, wird Chaincodeereigniscode für alle Controller-APIs mit Ausnahme der als Getter-APIs gekennzeichneten APIs generiert. Die folgenden Beispiele zeigen Controller-APIs mit Chaincodeereignissen, die sowohl für TypeScript als auch für Go aktiviert sind.
@Validator(yup.string(), yup.string(), yup.string())
public async createAccount(org_id: string, user_id: string, token_type: string) {
  await this.Ctx.Auth.checkAuthorization("ACCOUNT.createAccount", "TOKEN", { org_id });
  await this.Ctx.Model.createEvent(EVENT_NAME.CREATE_ACCOUNT, { org_id, user_id, token_type });
  return await this.Ctx.Account.createAccount(org_id, user_id, token_type);
}
func (t *Controller) CreateAccount(org_id string, user_id string, token_type string, daily_limits ...account.AccountDailyLimits) (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())
    }
    err = t.Ctx.Model.CreateEvent(constants.CreateAccountEventName, map[string]interface{}{"org_id": org_id, "user_id": user_id, "token_type": token_type})
    if err != nil {
        return nil, err
    }
    return t.Ctx.Account.CreateAccount(org_id, user_id, token_type, daily_limits...)
}
Chaincode-Ereignisse werden mit den folgenden Standardwerten generiert. Sie können diese Werte nach Bedarf ändern.
  • EventName: Der Name der Controllerfunktion.
  • Payload: Ein JSON-Objekt, das alle Eingabeparameter der Controllerfunktion enthält.