Creación de un token

Tokeniza un activo utilizando tokens.

Requisitos previos

  • Completa la sección de inicio rápido.

  • Crea una nueva cuenta.

  • Carga la cuenta con suficientes bitxor para pagar las tarifas de transacción.

Método #01: Usando la billetera de escritorio

  1. Haz clic en la pestaña �?strong>Tokens�?en el menú lateral izquierdo.

  2. Haz clic en la pestaña �?strong>Crear nuevos tokens�?en la parte superior de la página.

resources/images/screenshots/desktop-create-token-1.gif

3. Determina las propiedades del token que deseas crear. Puedes leer “Propiedades del token�?/span> para decidir cómo deseas configurar tu token. Haz clic en �?strong>Enviar�?

resources/images/screenshots/desktop-create-token-2.gif

  1. Verifica la información en el cuadro emergente e ingresa la contraseña de tu billetera. Haz clic en �?strong>Confirmar�? Esto enviará la transacción a la red.

resources/images/screenshots/desktop-create-token-3.gif

  1. Cuando la transacción se confirme, puedes verificar que el token se haya creado volviendo a la pestaña �?strong>Tokens propiedad�?

Método #02: Usando el SDK

1. Abre un nuevo archivo y define una transacción de definición de token. Esta transacción define las propiedades del token que tendrás. Puedes leer Propiedades del Token para decidir cómo deseas configurar tu token.

View Code
// replace with network type
const networkType = NetworkType.TEST_NET;
// replace with private key
const privateKey =
  '1111111111111111111111111111111111111111111111111111111111111111';
const account = Account.createFromPrivateKey(privateKey, networkType);
// replace with duration (in blocks)
const duration = UInt64.fromUint(0);
// replace with custom token flags
const isSupplyMutable = true;
const isTransferable = true;
const isRestrictable = true;
// replace with custom divisibility
const divisibility = 0;

const nonce = TokenNonce.createRandom();
const tokenDefinitionTransaction = TokenDefinitionTransaction.create(
  Deadline.create(epochAdjustment),
  nonce,
  TokenId.createFromNonce(nonce, account.address),
  TokenFlags.create(isSupplyMutable, isTransferable, isRestrictable),
  divisibility,
  duration,
  networkType,
);
View Code
// replace with network type
const networkType = bitxor_sdk_1.NetworkType.TEST_NET;
// replace with private key
const privateKey =
  '1111111111111111111111111111111111111111111111111111111111111111';
const account = bitxor_sdk_1.Account.createFromPrivateKey(
  privateKey,
  networkType,
);
// replace with duration (in blocks)
const duration = bitxor_sdk_1.UInt64.fromUint(0);
// replace with custom token flags
const isSupplyMutable = true;
const isTransferable = true;
const isRestrictable = true;
// replace with custom divisibility
const divisibility = 0;
const nonce = bitxor_sdk_1.TokenNonce.createRandom();
const tokenDefinitionTransaction = bitxor_sdk_1.TokenDefinitionTransaction.create(
  bitxor_sdk_1.Deadline.create(epochAdjustment),
  nonce,
  bitxor_sdk_1.TokenId.createFromNonce(nonce, account.address),
  bitxor_sdk_1.TokenFlags.create(
    isSupplyMutable,
    isTransferable,
    isRestrictable,
  ),
  divisibility,
  duration,
  networkType,
);
View Code
        // replace with node endpoint
        try (final RepositoryFactory repositoryFactory = new RepositoryFactoryVertxImpl(
                "NODE_URL")) {
            final NetworkType networkType = repositoryFactory.getNetworkType().toFuture().get();
            // replace with private key
            final String privateKey = "1111111111111111111111111111111111111111111111111111111111111111";
            final Account account = Account
                    .createFromPrivateKey(privateKey, networkType);
            // replace with duration (in blocks)
            final BlockDuration duration = new BlockDuration(10);
            // replace with custom token flags
            final boolean isSupplyMutable = true;
            final boolean isTransferable = true;
            final boolean isRestrictable = true;
            // replace with custom divisibility
            final int divisibility = 0;

            final TokenNonce nonce = TokenNonce.createRandom();

            final TokenDefinitionTransaction tokenDefinitionTransaction = TokenDefinitionTransactionFactory
                    .create(networkType,
                            nonce,
                            TokenId.createFromNonce(nonce, account.getPublicAccount()),
                            TokenFlags.create(isSupplyMutable, isTransferable, isRestrictable),
                            divisibility,
                            duration)
                    .build();

2. Define una transacción de cambio de suministro de token para establecer el suministro inicial. Por ejemplo, podemos establecerlo en 1,000,000 unidades de token.

View Code
// replace with token units to increase
const delta = 1000000;

const tokenSupplyChangeTransaction = TokenSupplyChangeTransaction.create(
  Deadline.create(epochAdjustment),
  tokenDefinitionTransaction.tokenId,
  TokenSupplyChangeAction.Increase,
  UInt64.fromUint(delta * Math.pow(10, divisibility)),
  networkType,
);
View Code
// replace with token units to increase
const delta = 1000000;
const tokenSupplyChangeTransaction = bitxor_sdk_1.TokenSupplyChangeTransaction.create(
  bitxor_sdk_1.Deadline.create(epochAdjustment),
  tokenDefinitionTransaction.tokenId,
  bitxor_sdk_1.TokenSupplyChangeAction.Increase,
  bitxor_sdk_1.UInt64.fromUint(delta * Math.pow(10, divisibility)),
  networkType,
);
View Code
            // replace with token units to increase
            final int delta = 1000000;
            final TokenSupplyChangeTransaction tokenSupplyChangeTransaction = TokenSupplyChangeTransactionFactory
                    .create(
                            networkType,
                            tokenDefinitionTransaction.getTokenId(),
                            TokenSupplyChangeActionType.INCREASE,
                            BigDecimal.valueOf(delta * Math.pow(10, divisibility)).toBigInteger())
                    .build();

Note

Bitxor funciona con cantidades absolutas. Para obtener una cantidad absoluta, multiplica la cantidad de activos que deseas crear por 10divisibility. Por ejemplo, si el token tiene una divisibilidad de 2, para crear 10 unidades (relativas) debes definir 1000 (absolutas) en su lugar.

3. Anuncia ambas transacciones juntas utilizando una transacción de agregación. Incluye el hash de generación de red para que la transacción solo sea válida para tu red. Abre la URL del nodo NODE_URL /node/info en una nueva pestaña del navegador y copia el valor de meta.networkGenerationHash.

View Code
const aggregateTransaction = AggregateTransaction.createComplete(
  Deadline.create(epochAdjustment),
  [
    tokenDefinitionTransaction.toAggregate(account.publicAccount),
    tokenSupplyChangeTransaction.toAggregate(account.publicAccount),
  ],
  networkType,
  [],
  UInt64.fromUint(2000000),
);

// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
  '1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = account.sign(
  aggregateTransaction,
  networkGenerationHash,
);
// replace with node endpoint
const nodeUrl = 'NODE_URL';
const repositoryFactory = new RepositoryFactoryHttp(nodeUrl);
const transactionHttp = repositoryFactory.createTransactionRepository();

transactionHttp.announce(signedTransaction).subscribe(
  (x) => console.log(x),
  (err) => console.error(err),
);
View Code
const aggregateTransaction = bitxor_sdk_1.AggregateTransaction.createComplete(
  bitxor_sdk_1.Deadline.create(epochAdjustment),
  [
    tokenDefinitionTransaction.toAggregate(account.publicAccount),
    tokenSupplyChangeTransaction.toAggregate(account.publicAccount),
  ],
  networkType,
  [],
  bitxor_sdk_1.UInt64.fromUint(2000000),
);
// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
  '1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = account.sign(
  aggregateTransaction,
  networkGenerationHash,
);
// replace with node endpoint
const nodeUrl = 'NODE_URL';
const repositoryFactory = new bitxor_sdk_1.RepositoryFactoryHttp(nodeUrl);
const transactionHttp = repositoryFactory.createTransactionRepository();
transactionHttp.announce(signedTransaction).subscribe(
  (x) => console.log(x),
  (err) => console.error(err),
);
View Code
            final AggregateTransaction aggregateTransaction = AggregateTransactionFactory
                    .createComplete(
                            networkType,
                            Arrays.asList(
                                tokenDefinitionTransaction.toAggregate(account.getPublicAccount()),
                                tokenSupplyChangeTransaction.toAggregate(account.getPublicAccount())
                            ))
                    .maxFee(BigInteger.valueOf(2000000)).build();

            final String generationHash = repositoryFactory.getGenerationHash().toFuture().get();
            final SignedTransaction signedTransaction = account
                    .sign(aggregateTransaction, generationHash);


            final TransactionRepository transactionRepository = repositoryFactory
                    .createTransactionRepository();
            transactionRepository.announce(signedTransaction).toFuture().get();
        }

Una vez que la transacción se confirme, puedes intentar transferir una unidad del token creado a otra cuenta, modificar las propiedades del token o vincular un espacio de nombres al token.

Método #03: Usando la CLI

Abre una ventana de terminal y ejecuta el siguiente comando.

View Code
bitxor-cli transaction token