Eventos de código de cadena

La versión mejorada de Blockchain App Builder puede generar eventos de código de cadenas para operaciones de token.

Los eventos de código de cadenas son notificaciones específicas que se emiten cuando se ejecutan transacciones. Los eventos incluyen información de transacciones que se puede utilizar para notificar a sistemas externos sobre condiciones específicas o cambios en el estado del libro mayor de blockchain. Puede utilizar eventos de código de cadenas para permitir la integración e interacción en tiempo real con aplicaciones que no están en la cadena de bloques, y para facilitar flujos de trabajo y la supervisión basados en eventos en todo el entorno de blockchain. Los eventos de código de cadenas tienen dos componentes: el nombre del evento y la carga útil.

Los eventos de código de cadenas están soportados para todos los archivos de especificación de Blockchain App Builder. Si activa los eventos de código de cadenas, todas las funciones de controlador del proyecto en andamios emitirán eventos, excepto los métodos getter. Por ejemplo, en un escenario de token, los eventos de código de cadena se emitirán cuando los tokens se acuñen, transfieran, quemen o bloqueen

Utilice el parámetro booleano events en el archivo de especificación para activar los eventos de código de cadenas, como se muestra en el siguiente ejemplo.

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

Si activa eventos, las funciones del controlador en el proyecto de código de cadenas de andamios incluirán métodos de creación de eventos, como se muestra en los siguientes ejemplos.

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);
}

Ir:

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...)
}

Los eventos de código de cadenas utilizan los siguientes valores por defecto para los componentes de nombre y carga útil. Puede modificar los valores predeterminados según sea necesario.

EventName: Nombre de la función de controlador.
Carga Útil: Objeto JSON que contiene todos los parámetros de entrada de la función de controlador.

También se ha agregado un nuevo parámetro events a los detalles del token en el marco de taxonomía de token ampliado y los estándares ERC-1155. Si el parámetro events del archivo de especificación se define en true, el parámetro events del token generado se define en true. Si el parámetro events del archivo de especificación se define en false o no se define, el parámetro events del token generado se define en false. Los siguientes ejemplos muestran un token con el nuevo parámetro events tanto para TypeScript como para 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"
}

Generación de Eventos

El método stub.setEvent permite al código de cadenas crear y emitir un evento cuando se ejecuta una transacción. El siguiente código muestra la versión TypeScript del método.

async setEvent(eventName: string, payload: Buffer): Promise<void>

En este ejemplo, eventName es el nombre que se va a asignar al evento y payload son datos asociados al evento. La carga útil puede contener cualquier información que desee enviar con el evento, normalmente serializada en formato JSON.

Eventos de código de cadenas para métodos de lote

El estándar ERC-1155 mejorado admite métodos por lotes. Los métodos por lotes funcionan en varios tokens que se transfieren como parámetros. Para los métodos por lotes, los eventos de código de cadenas se emiten solo para los tokens en los que el parámetro events está definido en true en el archivo de especificación.

Para cada transacción completada en el método por lotes, se genera un evento de código de cadenas correspondiente. La carga útil de cada evento de código de cadena contiene los detalles de la transacción. Por ejemplo, si utiliza el método BatchTransfer para transferir cantidades de cinco tokens diferentes, se emiten cinco eventos de código de cadenas correspondientes. La carga útil de cada evento contiene los detalles del token y la cantidad transferida, junto con parámetros comunes que se aplican a todas las transferencias por lotes.

El siguiente ejemplo muestra el código de eventos utilizando el estándar ERC-1155 mejorado.

@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);
  }

Eventos de código de cadenas para varios activos

El marco de taxonomía de token mejorado y los estándares ERC-1155 soportan la definición de más de un activo de token en un archivo de especificación. El comportamiento del evento de código de cadenas es diferente según si un método es específico del token (como crear o actualizar un token) o común (como acuñar o grabar).

Para métodos específicos de token, los eventos de código de cadena se generan solo para los tokens en los que el parámetro events está definido en true en el archivo de especificación.

Para métodos comunes, los eventos de código de cadenas se generan en el proyecto andamio si algún token tiene el parámetro events definido en true en el archivo de especificación. El comportamiento real del evento de código de cadena se basa en el número de parámetros de ID de token transferidos al método.

Si se transfiere un único ID de token como parámetro, los eventos de código de cadenas se generan solo si el parámetro events de los detalles de token correspondientes se define en true.
Si se transfieren varios ID de token como parámetros, los eventos de código de cadenas se generan solo si el parámetro events de cualquiera de los detalles de token está definido en true.
Si no se transfiere ningún ID de token como parámetro, siempre se generan eventos de código de cadenas.

La siguiente lista muestra métodos comunes a los que se deben transferir dos tokens. Esta lista se aplica al estándar de marco de taxonomía de token ampliado.

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)

La siguiente lista muestra métodos comunes que no toman tokens como argumentos. La siguiente lista se aplica al estándar de marco de taxonomía de token ampliado.

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)

Esta lista muestra métodos comunes que no toman tokens como argumentos para el estándar ERC-1155 ampliado.

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 Métodos de SDK para eventos de Chaincode

createEvent

Este método genera eventos basados en un nombre de evento y una carga útil especificados.

public async createEvent(eventName: any, eventPayload: any, assets?: any)

Parámetros:

eventName: string: nombre del evento que se utilizará al generar eventos.
eventPayload: map[string]interface{}: carga útil de evento que se utilizará al generar eventos.
assets: opcionalmente, el activo de token se puede transferir como parámetro al método.

createEventForBatch

Este método genera eventos para operaciones por lotes, como los métodos mintBatch o burnBatch.

public async createEventForBatch(eventName: any, eventPayload: any, quantities: number[], assets: any)

Parámetros:

eventName: string: nombre del evento que se utilizará al generar eventos.
eventPayload: map[string]interface{}: carga útil de evento que se utilizará al generar eventos.
quantities: number[]: lista de importes, correspondientes a cada ID de token, que representan el número de tokens que se utilizarán en las transacciones de método por lotes.
assets: opcionalmente, el activo de token se puede transferir como parámetro al método.

Métodos de SDK de Go para eventos de código de cadenas

CreateEvent

Este método genera eventos basados en un nombre de evento y una carga útil especificados.

func (m *Model) CreateEvent(eventName string, eventPayload map[string]interface{}, assets ...interface{})

Parámetros:

eventName: string: nombre del evento que se utilizará al generar eventos.
eventPayload: map[string]interface{}: carga útil de evento que se utilizará al generar eventos.
assets: opcionalmente, el activo de token se puede transferir como parámetro al método.

CreateEventForBatch

Este método genera eventos para operaciones por lotes, como los métodos mintBatch o burnBatch.

func (m *Model) CreateEventForBatch(eventName string, eventPayload map[string]interface{}, quantities []float64, assets []interface{})

Parámetros:

eventName: string: nombre del evento que se utilizará al generar eventos.
eventPayload: map[string]interface{}: carga útil de evento que se utilizará al generar eventos.
quantities: []float64: lista de importes, correspondientes a cada ID de token, que representan el número de tokens que se utilizarán en las transacciones de método por lotes.
assets: opcionalmente, el activo de token se puede transferir como parámetro al método.

Generación de eventos en código de cadena de creador de aplicaciones blockchain

Si el parámetro events del archivo de especificación se define en true, se genera el código de eventos de código de cadenas para todas las API de controlador, excepto las designadas como API getter. Los siguientes ejemplos muestran las API de controlador con eventos de código de cadenas activados para TypeScript y Go.

@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...)
}

Los eventos de código de cadenas se generan con los siguientes valores por defecto. Puede modificar estos valores según sea necesario.

EventName: nombre de la función de controlador.
Payload: objeto JSON que contiene todos los parámetros de entrada de la función de controlador.