Wrong cosigner when converting account to multisig account

[kahwooi]

I am following this https://nemtech.github.io/guides/account/converting-an-account-to-multisig.html to convert an account to a multisig account.

The transaction is announce successfully, but the wired part is at the Cosign the AggregateTransaction .

I am expecting Alice and Bob to consign the aggregate transaction, but non of them receive the aggregateBondedTransactions.

When I try to use the multisig account to consign it, and it did go through successfully. I am confuse.

This is how I cosign the aggregate transaction, and using multisig account went through:

accountHttp
    .aggregateBondedTransactions(multisigAccount.publicAccount, new QueryParams(100))
    .pipe(
        mergeMap((_) => _),
        filter((_) => _.transactionInfo !== undefined && _.transactionInfo.hash !== undefined &&
            _.transactionInfo.hash === hash), // Filter transaction
        toArray(),
    )
    .subscribe((transactions: AggregateTransaction[]) => {
        console.log(transactions.length)
        if (transactions.length) {
            const transaction = transactions[0];
            const cosignatureTransaction = CosignatureTransaction.create(transaction);
            const signedCosignature = multisigAccount.signCosignatureTransaction(cosignatureTransaction);

            transactionHttp.announceAggregateBondedCosignature(signedCosignature).subscribe(
                () => {
                    console.log('Transaction cosigned and announced correctly');
                }, (err) => {
                    console.log(err.response !== undefined ? err.response.text : err);
                });

        }
    });

I am using below:
"nem2-sdk": "^0.13.1"
"catapult-server":"v0.5.0.1"

---

Related issue:

After signed by multisig account, I try to getMultisigAccountInfo:

accountHttp
.getMultisigAccountInfo(address)
.subscribe(accountInfo => console.log(accountInfo), err => console.error(err));

I get an error and undefined result:

body: MultisigAccountInfoDTO { multisig: undefined } }

[dgarcia360]

Hi @kahwooi,

As you have remarked, Alice and Bob need to opt-in in order to create the multisig account. We need to figure out why you are not receiving the aggregate bonded transaction. Could you paste here the complete code you are using to create the multisig account?

Although you are able to announce a cosignature from the candidate multisig account, this cosignature should not have any effect as Alice and Bob still need to cosign the transaction.

[kahwooi]

This is how I announce it:

import { TransactionHttp, Listener, Account, NetworkType, PublicAccount, 
    ModifyMultisigAccountTransaction, Deadline, MultisigCosignatoryModification, MultisigCosignatoryModificationType, AggregateTransaction, HashLockTransaction, NetworkCurrencyMosaic, UInt64 } from "nem2-sdk";
import { filter, mergeMap } from 'rxjs/operators' 

const nodeUrl = 'http://localhost:3000'
const transactionHttp = new TransactionHttp(nodeUrl)
const listener = new Listener(nodeUrl)

//multisig
const accountPrivateKey = '636DD04F4C88C7B6...';
const multisigAccount = Account.createFromPrivateKey(accountPrivateKey , NetworkType.MIJIN_TEST);
//alice
const alicePublicKey = 'D083746AB1335495CDE4A1...'
const cosignatory1 = PublicAccount.createFromPublicKey(alicePublicKey, NetworkType.MIJIN_TEST);
//bob
const bobPublicKey = '1F4C94B5B622C003117...'
const cosignatory2 = PublicAccount.createFromPublicKey(bobPublicKey, NetworkType.MIJIN_TEST);

//MultisigAccountModificationTransaction
const convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.create(
    Deadline.create(),
    1,
    1,
    [
        new MultisigCosignatoryModification(
            MultisigCosignatoryModificationType.Add,
            cosignatory1,
        ),
        new MultisigCosignatoryModification(
            MultisigCosignatoryModificationType.Add,
            cosignatory2,
        )],
    NetworkType.MIJIN_TEST)

//AggregateBondedTransaction
const aggregateTransaction = AggregateTransaction.createBonded(
    Deadline.create(),
    [convertIntoMultisigTransaction.toAggregate(multisigAccount.publicAccount)],
    NetworkType.MIJIN_TEST)

//Sign tx with the multisig account
const networkGenerationHash = '8505335DDE38967F78400FEA3FFB75...';
const signedTransaction = multisigAccount.sign(aggregateTransaction, networkGenerationHash);
console.log(signedTransaction.hash);

//app_provider
const appProviderPrivateKey = 'BED47F18F7EBDDF773444967E441....';
const appProviderAccount = Account.createFromPrivateKey(appProviderPrivateKey, NetworkType.MIJIN_TEST);

//lock 10 cat.currancy using app_provider account
const hashLockTransaction = HashLockTransaction.create(
    Deadline.create(),
    NetworkCurrencyMosaic.createRelative(10),
    UInt64.fromUint(480),
    signedTransaction,
    NetworkType.MIJIN_TEST)
const hashLockTransactionSigned = appProviderAccount.sign(hashLockTransaction, networkGenerationHash);

listener.open().then(() => {

    //annouce hash lock transaction
    transactionHttp
        .announce(hashLockTransactionSigned)
        .subscribe(x => console.log(x), err => console.error(err));

    //confirm hash lock transaction, then annouce AggregateTransaction 
    listener
        .confirmed(appProviderAccount.address)
        .pipe(
            filter((transaction) => transaction.transactionInfo !== undefined
                && transaction.transactionInfo.hash === hashLockTransactionSigned.hash),
            mergeMap(ignored => transactionHttp.announceAggregateBonded(signedTransaction))
        )
        .subscribe(announcedAggregateBonded => console.log(announcedAggregateBonded),
            err => console.error(err));
})

---

This two command show nothing:

nem2-cli transaction cosign --hash A6A374E66B32A3D5133018EFA9CD6E3... --profile alice  
nem2-cli transaction cosign --hash A6A374E66B32A3D5133018EFA9CD6E3... --profile bob

Only multisig account work:
nem2-cli transaction cosign --hash A6A374E66B32A3D5133018EFA9CD6E3... --profile multisig

[evias]

after review of the code, it seems correct. I am not sure about the appProviderAccount which signs the HashLockTransaction as this account is not linked in the loop otherwise. Maybe a cosignatory must sign the hashlock? @dgarcia360 can someone else pay for the hashlock ? Knowing the hashlock is linked to the SignedTransaction, it is possible, but would want to confirm.

But I would think that Alice and Bob not being notified is still a bug because if the aggregate bonded transaction gets announced, as david points out they must opt-in to the multi-signature config.

[kahwooi]

I have gone through my code above many time, tested many times, Alice and Bob account din't receive any aggregate bonded notification, but Multisig account receive it. I don't know what has gone wrong. What are the things I can look at, e.g config or some other code example?

[dgarcia360]

Hi @kahwooi, thanks for sharing the complete code! After running the example several times, I didn't manage either to get the aggregated bonded transaction modification from the cosignatory account. Core devs are informed, it will be necessary to make Alice and Bob receivers of the notification as well to make this feature more usable.

In the meanwhile, we will update the docs with a workaround. You can still opt-in the transaction with Alice and Bob profiles. How? Querying the transaction from the future multisig account partial channel. Here you have a code snippet you can use to opt-in ModifyMultisigModificationTransactions https://gist.github.com/dgarcia360/32c97c99c4c18e801421d352feba2ce6

To finish the use case presented, you will have to run the snippet twice: one setting Alice's account as the cosignatoryPrivateKey and a second one with Bob's account.

@evias can someone else pay for the hashlock ? Yes, this is possible. The code looks correct, it's a docs + feature behaviour problem.

[rg911]

@Wayonb

[jorisadri]

Any update on this issue?

[dgarcia360]

@jorisadri Note from devs: Next Catapult release major release should notify as well the potential cosignatories.

[rg911]

I was going to ask the same question, Thanks @dgarcia360 . but do we have any insight of what's going on with this issue, and what changes potentially are needed?

[dgarcia360]

If an account is added as a potential multisig account cosignatory, this will receive a notification through the aggregatebonded channel to opt-in. Theoretically, we don't need to change anything in the SDK/REST level.