Esta guía te mostrará cómo emitir transacciones desde una cuenta multisig.
En este ejemplo, Alice y Bob son cosignatarios de una cuenta multisig 1-de-2. Esta configuración de multisig permite a Alice y Bob compartir fondos en una cuenta separada, requiriendo solo la firma de uno de ellos para realizar transacciones.
Vamos a enviar 10 bitxor desde la cuenta compartida a una tercera dirección.
Completa la guía de enviar tokens y mensajes entre dos cuentas.
Completa la guía de convertir una cuenta en multisig.
Carga la cuenta multisig 1-de-2 con 10 unidades de bitxor.
Carga la cuenta de Bob con suficientes unidades de bitxor para pagar las tarifas de las transacciones.
Inicia sesión en una de las cuentas cosignatarias de la multisig.
Haz clic en la pestaña “transferencia”.
Ingresa la información adecuada para tu transacción de transferencia. Selecciona la cuenta multisig en el menú desplegable del campo “DE”. Ingresa la dirección del destinatario. Selecciona el token que deseas enviar y la cantidad. Haz clic en “Enviar”. Revisa la información en el cuadro emergente e ingresa la contraseña de tu billetera. Haz clic en “Confirmar”.
Si la cuenta multisig tiene el valor de “aprobación mínima” establecido en un número mayor que 1, inicia sesión en otra cuenta cosignataria y firma la transacción. Repite este paso hasta que se cumpla el número mínimo de aprobaciones.
Una vez que la transacción se confirme, deberías ver cambios en los saldos de las respectivas cuentas.
Define la clave privada de uno de los cosignatarios de la multisig en una nueva variable. Luego, define la clave pública de la cuenta compartida.
// replace network type
const networkType = NetworkType.TEST_NET;
// replace with cosignatory private key
const cosignatoryPrivateKey =
'0000000000000000000000000000000000000000000000000000000000000000';
const cosignatoryAccount = Account.createFromPrivateKey(
cosignatoryPrivateKey,
networkType,
);
// replace with multisig account public key
const multisigAccountPublicKey =
'3A537D5A1AF51158C42F80A199BB58351DBF3253C4A6A1B7BD1014682FB595EA';
const multisigAccount = PublicAccount.createFromPublicKey(
multisigAccountPublicKey,
networkType,
);
// replace with recipient address
const recipientRawAddress = 'BXRYXK-VYBMO4-NBCUF3-AXKJMX-CGVSYQ-OS7ZG2-TLI';
const recipientAddress = Address.createFromRawAddress(recipientRawAddress);
// replace with bitxor id
const networkCurrencyTokenId = new TokenId('5E62990DCAC5BE8A');
// replace with network currency divisibility
const networkCurrencyDivisibility = 6;
// replace network type
const networkType = bitxor_sdk_1.NetworkType.TEST_NET;
// replace with cosignatory private key
const cosignatoryPrivateKey =
'0000000000000000000000000000000000000000000000000000000000000000';
const cosignatoryAccount = bitxor_sdk_1.Account.createFromPrivateKey(
cosignatoryPrivateKey,
networkType,
);
// replace with multisig account public key
const multisigAccountPublicKey =
'3A537D5A1AF51158C42F80A199BB58351DBF3253C4A6A1B7BD1014682FB595EA';
const multisigAccount = bitxor_sdk_1.PublicAccount.createFromPublicKey(
multisigAccountPublicKey,
networkType,
);
// replace with recipient address
const recipientRawAddress = 'BXRYXK-VYBMO4-NBCUF3-AXKJMX-CGVSYQ-OS7ZG2-TLI';
const recipientAddress = bitxor_sdk_1.Address.createFromRawAddress(
recipientRawAddress,
);
// replace with bitxor id
const networkCurrencyTokenId = new bitxor_sdk_1.TokenId('5E62990DCAC5BE8A');
// replace with network currency divisibility
const networkCurrencyDivisibility = 6;
NetworkType networkType = repositoryFactory.getNetworkType().toFuture().get();
// replace with cosignatory private key
String cosignatoryPrivateKey = "";
Account cosignatoryAccount = Account.createFromPrivateKey(cosignatoryPrivateKey, networkType);
// replace with cosignatory private key
String multisigAccountPublicKey = "";
Account multisigAccount = Account.createFromPrivateKey(multisigAccountPublicKey, networkType);
// replace with recipient address
String recipientRawAddress = "BXRYXK-VYBMO4-NBCUF3-AXKJMX-CGVSYQ-OS7ZG2-TLI";
Address recipientAddress = Address.createFromRawAddress(recipientRawAddress);
NetworkCurrency networkCurrency = repositoryFactory.getNetworkCurrency().toFuture().get();
Define una transacción de transferencia de la siguiente manera:
Propiedad |
Valor |
|---|---|
Tipo |
TransferTransaction |
Destinatario |
Dirección de la cuenta que recibirá la transacción |
Tokens |
[10 |
Mensaje |
enviando 10 |
const transferTransaction = TransferTransaction.create(
Deadline.create(epochAdjustment),
recipientAddress,
[
new Token(
networkCurrencyTokenId,
UInt64.fromUint(10 * Math.pow(10, networkCurrencyDivisibility)),
),
],
PlainMessage.create('sending 10 bitxor'),
networkType,
);
const transferTransaction = bitxor_sdk_1.TransferTransaction.create(
bitxor_sdk_1.Deadline.create(epochAdjustment),
recipientAddress, [
new bitxor_sdk_1.Token(
networkCurrencyTokenId,
bitxor_sdk_1.UInt64.fromUint(
10 * Math.pow(10, networkCurrencyDivisibility),
),
),
],
bitxor_sdk_1.PlainMessage.create('sending 10 bitxor'),
networkType,
);
TransferTransaction transferTransaction = TransferTransactionFactory.create(networkType, recipientAddress,
Collections.singletonList(networkCurrency.createRelative(BigInteger.valueOf(10))),
PlainMessage.create("sending 10 bitxor")).build();
Envuelve la TransferTransaction en una transacción agregada, adjuntando la clave pública de la multisig como el firmante de la transacción.
const aggregateTransaction = AggregateTransaction.createComplete(
Deadline.create(epochAdjustment),
[transferTransaction.toAggregate(multisigAccount)],
networkType,
[],
UInt64.fromUint(2000000),
);
const aggregateTransaction = bitxor_sdk_1.AggregateTransaction.createComplete(
bitxor_sdk_1.Deadline.create(epochAdjustment), [transferTransaction.toAggregate(multisigAccount)],
networkType, [],
bitxor_sdk_1.UInt64.fromUint(2000000),
);
AggregateTransaction aggregateTransaction = AggregateTransactionFactory.createComplete(networkType,
Collections.singletonList(transferTransaction.toAggregate(multisigAccount.getPublicAccount())))
.maxFee(BigInteger.valueOf(2000000)).build();
Luego, firma y anuncia la transacción con una cuenta cosignataria.
// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
'1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = cosignatoryAccount.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),
);
// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
'1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = cosignatoryAccount.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),
);
String generationHash = repositoryFactory.getGenerationHash().toFuture().get();
SignedTransaction signedTransaction = cosignatoryAccount.sign(aggregateTransaction, generationHash);
try (Listener listener = repositoryFactory.createListener()) {
listener.open().get();
TransactionService transactionService = new TransactionServiceImpl(repositoryFactory);
transactionService.announce(listener, signedTransaction).toFuture().get();
}
El destinatario de la transacción debería recibir los fondos una vez que se confirmen.
Este time, la TransferTransaction fue envuelta en una AggregateCompleteTransaction porque solo se requería una cuenta para anunciar la transacción. Si se requiere más de una cosignatura para anunciar la transacción (por ejemplo, la multisig es una cuenta 2-de-2), la transacción debe ser definida como aggregate bonded, y todos los otros participantes de la multisig deben cosignarla para ser confirmada.
Para emitir una transacción desde una multisig 2-de-2, modifica el código anterior y define la transacción como bonded.
const aggregateTransaction = AggregateTransaction.createBonded(
Deadline.create(epochAdjustment),
[transferTransaction.toAggregate(multisigAccount)],
networkType,
[],
UInt64.fromUint(2000000),
);
// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
'1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = cosignatoryAccount.sign(
aggregateTransaction,
networkGenerationHash,
);
console.log(signedTransaction.hash);
const aggregateTransaction = bitxor_sdk_1.AggregateTransaction.createBonded(
bitxor_sdk_1.Deadline.create(epochAdjustment), [transferTransaction.toAggregate(multisigAccount)],
networkType, [],
bitxor_sdk_1.UInt64.fromUint(2000000),
);
// replace with meta.networkGenerationHash (nodeUrl + '/node/info')
const networkGenerationHash =
'1DFB2FAA9E7F054168B0C5FCB84F4DEB62CC2B4D317D861F3168D161F54EA78B';
const signedTransaction = cosignatoryAccount.sign(
aggregateTransaction,
networkGenerationHash,
);
console.log(signedTransaction.hash);
NetworkType networkType = repositoryFactory.getNetworkType().toFuture().get();
// replace with cosignatory private key
String cosignatoryPrivateKey = "";
Account cosignatoryAccount = Account.createFromPrivateKey(cosignatoryPrivateKey, networkType);
// replace with cosignatory private key
String multisigAccountPublicKey = "";
Account multisigAccount = Account.createFromPrivateKey(multisigAccountPublicKey, networkType);
// replace with recipient address
String recipientRawAddress = "BXRYXK-VYBMO4-NBCUF3-AXKJMX-CGVSYQ-OS7ZG2-TLI";
Address recipientAddress = Address.createFromRawAddress(recipientRawAddress);
NetworkCurrency networkCurrency = repositoryFactory.getNetworkCurrency().toFuture().get();
TransferTransaction transferTransaction = TransferTransactionFactory.create(networkType, recipientAddress,
Collections.singletonList(networkCurrency.createRelative(BigInteger.valueOf(10))),
PlainMessage.create("sending 10 bitxor")).build();
AggregateTransaction aggregateTransaction = AggregateTransactionFactory.createBonded(networkType,
Collections.singletonList(transferTransaction.toAggregate(multisigAccount.getPublicAccount())))
.maxFee(BigInteger.valueOf(2000000)).build();
String generationHash = repositoryFactory.getGenerationHash().toFuture().get();
SignedTransaction signedTransaction = cosignatoryAccount.sign(aggregateTransaction, generationHash);
Cuando una AggregateTransaction está bonded, una cuenta debe bloquear al menos 10 bitxor para evitar el spam en la red. Una vez que todos los cosignatarios firmen la transacción, la cantidad de bitxor bloqueada vuelve a estar disponible en la cuenta que bloqueó los fondos. Después de que se confirme la HashLockTransaction, anuncia la AggregateBondedTransaction con un cosignatario. En nuestro caso, firmaremos la transacción con la cuenta de Bob.
const hashLockTransaction = HashLockTransaction.create(
Deadline.create(epochAdjustment),
new Token(
networkCurrencyTokenId,
UInt64.fromUint(10 * Math.pow(10, networkCurrencyDivisibility)),
),
UInt64.fromUint(480),
signedTransaction,
networkType,
UInt64.fromUint(2000000),
);
const signedHashLockTransaction = cosignatoryAccount.sign(
hashLockTransaction,
networkGenerationHash,
);
// replace with node endpoint
const nodeUrl = 'NODE_URL';
const repositoryFactory = new RepositoryFactoryHttp(nodeUrl);
const listener = repositoryFactory.createListener();
const receiptHttp = repositoryFactory.createReceiptRepository();
const transactionHttp = repositoryFactory.createTransactionRepository();
const transactionService = new TransactionService(transactionHttp, receiptHttp);
listener.open().then(() => {
transactionService
.announceHashLockAggregateBonded(
signedHashLockTransaction,
signedTransaction,
listener,
)
.subscribe(
(x) => console.log(x),
(err) => console.log(err),
() => listener.close(),
);
});
const hashLockTransaction = bitxor_sdk_1.HashLockTransaction.create(
bitxor_sdk_1.Deadline.create(epochAdjustment),
new bitxor_sdk_1.Token(
networkCurrencyTokenId,
bitxor_sdk_1.UInt64.fromUint(
10 * Math.pow(10, networkCurrencyDivisibility),
),
),
bitxor_sdk_1.UInt64.fromUint(480),
signedTransaction,
networkType,
bitxor_sdk_1.UInt64.fromUint(2000000),
);
const signedHashLockTransaction = cosignatoryAccount.sign(
hashLockTransaction,
networkGenerationHash,
);
// replace with node endpoint
const nodeUrl = 'NODE_URL';
const repositoryFactory = new bitxor_sdk_1.RepositoryFactoryHttp(nodeUrl);
const listener = repositoryFactory.createListener();
const receiptHttp = repositoryFactory.createReceiptRepository();
const transactionHttp = repositoryFactory.createTransactionRepository();
const transactionService = new bitxor_sdk_1.TransactionService(
transactionHttp,
receiptHttp,
);
listener.open().then(() => {
transactionService
.announceHashLockAggregateBonded(
signedHashLockTransaction,
signedTransaction,
listener,
)
.subscribe(
(x) => console.log(x),
(err) => console.log(err),
() => listener.close(),
);
});
HashLockTransaction hashLockTransaction = HashLockTransactionFactory
.create(networkType, networkCurrency.createRelative(BigDecimal.valueOf(10)), BigInteger.valueOf(480),
signedTransaction).build();
SignedTransaction signedHashLockTransaction = cosignatoryAccount.sign(hashLockTransaction, generationHash);
try (Listener listener = repositoryFactory.createListener()) {
listener.open().get();
TransactionService transactionService = new TransactionServiceImpl(repositoryFactory);
transactionService
.announceHashLockAggregateBonded(listener, signedHashLockTransaction, signedTransaction).toFuture()
.get();
}
Una vez que la transacción llegue a la red, todos los otros cosignatarios de la multisig requeridos para alcanzar el quorum deben cosignar la transacción.
Para cosignar la transacción, puedes usar el comando CLI transaction cosign, reemplazando el hash de la transacción del paso 2.
bitxor-cli transaction cosign --hash A6A374E66B32A3D5133018EFA9CD6E3169C8EEA339F7CCBE29C47D07086E068C --profile alice
El destinatario debería recibir los fondos una vez que la transacción sea cosignada por al menos minApproval cosignatarios. Además, la cuenta que bloqueó los 10 bitxor debería haber recibido los fondos bloqueados de vuelta.
Last updated by John Doe
on 2023‑06‑08.
