we should add a new test case for an account encoding each time the encoding
changes

* adds BuildTransaction worker job

we offload PostTransaction to the worker pool because proof generation is
compute intensive and could otherwise bog down the node process

creating an UnsignedTransaction using 'build' generates proofs and would create
the same problem

the new job allows us to offload compute to the worker pool in RPC calls that
build UnsignedTransactions

* fixes tests

* fixes BuildTransaction worker task

uses proofAuthorizingKey instead of proofGenerationKey as input to build

changes sizes of serialization for key change

* changes argument name in WorkerPool to proofAuthorizingKey

1. Consensus parameters
2. Genesis block
3. Definition

* updating account value with proofAuthorizationKey

* setting up migration

* Add headvalue to accountValue migration

* adding migration logic:

* adding pak to account and bech32

* changing proofAuthorizationKey to proofAuthorizingKey

* adding proof aurthorizing key to types and mnemonic

* adding default null value to proof authorizing key to previous migrations

* fixing lint issues

* updating wallet test slow

* adding key length to bech32 encoder

* adding flag for pak to bech32

* reverting fixture changes

* simplifying migration

* adding to list of all migrations

* bech32 decoder v3

* bech32 decoder v3

* bech32 test for proof authorizing key

* updating account schema version

* fixing typos

* reverting blockchain test fixture

* adding pak import testcases

* moving proof authorizing key to the back of the account

* moving proof authorizing key to the back of the account

* Move Consensus into Network

* Change constructor to positional args

* Move parameter copy to network

* Change miningReward to use consensus parameters

…4663)

* feat(ironfish): Add public key package without tests

* feat(ironfish): Update RpcAccountImport to have undefined multisig

* feat(ironfish): Update multiSigKeys to be undefined

* test(ironfish): Add test for multisig encoder

* refactor(ironfish): Remove un-needed key in exportAccount

* refactor(ironfish): Clean up lint

* refactor(ironfish): Clean up deserializeRpcAccountMultiSigKeys

* refactor(ironfish): Clean up

* feat(ironfish): Make public key package required

* refactor(ironfish): Remove unused import

* fix(ironfish): Check for all signer fields

* refactor(ironfish): Remove nullable

* test(ironfish): Add test cases for import

* test(ironfish): Update import tests

* feat(ironfish): Remove proofGenerationKey in tests

* fix(ironfish): Remove unneeded undefined

* refactor(ironfish): Clean up multisig encoder

)

* feat(ironfish): Add public key package without tests

* feat(ironfish): Update RpcAccountImport to have undefined multisig

* feat(ironfish): Update multiSigKeys to be undefined

* test(ironfish): Add test for multisig encoder

* refactor(ironfish): Remove un-needed key in exportAccount

* refactor(ironfish): Clean up lint

* refactor(ironfish): Clean up deserializeRpcAccountMultiSigKeys

* refactor(ironfish): Clean up

* feat(ironfish): Make public key package required

* refactor(ironfish): Remove unused import

* fix(ironfish): Check for all signer fields

* refactor(ironfish): Remove nullable

* test(ironfish): Add test cases for import

* test(ironfish): Update import tests

* feat(ironfish): Remove proofGenerationKey in tests

* fix(ironfish): Remove unneeded undefined

* refactor(ironfish): Clean up multisig encoder

* test(ironfish): Add coordinator account to integration frost test

* adds wallet/buildTransaction RPC

buildTransaction takes a serialized RawTransaction and returns a serialized
UnsignedTransaction

adds a 'build' method to the Wallet. for now, derives proofGenerationKey either
from an account's spendingKey or from the account's multiSigKeys. invokes the
buildTransaction worker pool task to build a RawTransaction

* fixes proofAuthorizingKey TODO

* adds test that buildTransaction RPC output can be signed

* changes 'transaction' name in request/response

uses explicit 'rawTransaction' and 'unsignedTransaction' names

if flag is set uses the wallet/buildTransaction RPC to build the raw transaction
to send

outputs unsigned transaction as hex string before exiting

flag is exclusive to the rawTransaction flag so that the command will output
either a rawTransaction or an unsignedTransaction

flag is hidden

* remove max signers from secret config

* updating typescript generated code

* updating usage of napi binding

* test utility for creating identifiers

* importing create_identifiers for split secret test

* removing comment

* updating wallet:slow test to remove max signers

* removing max signers from create trusted dealer package rpc

* removing max signers from createSigningPackage rpc

* adds multisig/aggregateSignatureShares RPC

takes a publicKeyPackage, an unsignedTransaction, a signingPackage for that
transaction, and a list of signatureShares for that signingPackage

uses UnsignedTransaction.signFrost to aggregate the signatureShares, sign the
transaction, and produce a signed transaction

returns a signed transaction serialized as hex

* fixes typo in RpcClient

s/Signature/Signing/

* fixes second typo

…4679)

* signing commitment now contains identifier

* removing identifiercommitment concept

* remove newline

* Reverting change to assert is signer

* fixing createSigningPackage test

…#4680)

* feat(cli,ironfish): Use base64json instead of bech32

* refactor(cli): Fix unused import

* test(ironfish): Update tests

* test(ironfish): Add test case for base64json

we are changing a number of multisig RPCs to accept an 'account' parameter in
requests

we will need to assert that the account passed to each one is a multisig account

adds an assertion for convenience that asserts that an account is a multisig
account

* changes createSigningShare RPC to take an account name

changes the RPC to take an account name as a request parameter instead of a
serialized keyPackage

loads the account for the given name and asserts that it is a multisig signing
account before using the keyPackage from that account

this avoids passing a keyPackage, which contains a sensitive secret, from being
passed through an RPC request

* adds tests for createSigningShare RPC

* accepts account name as input for createSigningCommitment

* using AssertMultiSig

* asserts that a trusted dealer cannot create a signing commitment

* removing node client depedency

…bject with identifier and signature share types (#4691)

* Adds error message to multi sig signer assert

1. Moves the function to the account file
2. Updates test to assert the error message

* using with required

* Rename to AssertMultiSigSigner

* updating test

This fixes a bug where you are not prompted to enter a new name for the
account in the case that the import is decoded in the server side.

* renames SigningShare to SignatureShare

the frost crates use the term SignatureShare to refer to a part of a signature,
but we have used the term SigningShare

the term 'SigningShare' can be confused with the 'signing_share' part of a key
package, used to create signing commitments and signature shares

renames SigningShare to SignatureShare in rust types, napi bindings, and
multisig RPCs

* updates test to use fully qualified rpc route

* WIP

* Fix conflict

* Remove duplicate file

* Fix lint

* test(ironfish): Fix commitment test

* allows minting asset with 0 supply

removes minimum mint amount from cli, rpc endpoints

it is useful to be able to mint an asset with 0 supply. for example, create
an asset before minting tokens corresponding to deposits

* fixes test for minting with zero supply

* refactors multiSig to multisig

* rename file

* rename back to multisigKeys

* more renaming

* finishing rebasing refactors

* feat: create signing package cli

* updates create-signing-package after refactors

* renames 'signingShareResponse' to 'signingPackageResponse'

---------

Co-authored-by: Hugh Cunningham <[email protected]>

we have a custom assertion to assert that an account has multisigKeys

ThreadRng shouldn't be used directly as it restricts the kinds of random
number generators that people can pass as an input

* feat: add multisig create signing commitment command

* add identifier to commitment output

* pr comment updates

* update to match new signing commitment RPC structure

* Rebase latest staging updates

* formatting

* hidden true for signing commitment cli

---------

Co-authored-by: Rohan Jadvani <[email protected]>

* feat: add create signing share cli command

* rebasing

* directly passing signature share to the rpc

* returning signatureShare string

---------

Co-authored-by: Rahul Patni <[email protected]>

* starting sign cli command

* basic signing share signing functionality

* leaving todos with open ended questions

* WIP

* Implement broadcast / accepted

* Fix flag description

* Update description

* Fix account character

* Update error

* PR feedback

* Make account optional

* Make account optional

* Update description

* Fix ux action

---------

Co-authored-by: Rohan Jadvani <[email protected]>

* feat(cli): Improve multisig account creation

* Fix key

* Fix keys

* adds multisig RPC integration test

integration test replicates the wallet test, but uses RPC requests and responses

the response for each step of the flow is used as an input to the request of the
next step

* updates multisig RPC integration test for latest changes in staging

* further updates from renaming and refactors

* updates for multiSig -> multisig rename

* adds wallet:multisig:identity:create

adds a cli command that generates a random secret and outputs the identity and
identifier for that secret

useful for creating identifiers for testing for now, but doesn't interact with
any RPC or persist any data

* hides the command

`Identity` holds more information than `Identifier` and hence should be
the preferred data structure. An `Identity` can always be converted to
`Identifier` but the other way around is not possible.

sets 'account' param in the buildTransaction RPC call

* Prompt user to enter a name for nameless account

This fix will now prompt the user to enter a name in the case that an
encoder throws an error because an account name was not provided. This
gest caught and forwarded to the front end so they can prompt the user
for a name to then try the import again.

* fixing lint

---------

Co-authored-by: Rahul Patni <[email protected]>

* chore: add code comment for encryption default nonce

* lint fix

---------

Co-authored-by: Rahul Patni <[email protected]>

* large prompt for account import

* repeat until user passes an input

* large prompt follows cli ux required interface

* using recursion

* creating readline interface out of the recursive loop

* updates to use recursive method

* fixing import name

---------

Co-authored-by: Joe <[email protected]>

* ux improvements for multisig command inputs

* large prompt to long prompt

commit 619a539 updated the wallet to support
minting an asset and sending the minted notes in the same transaction

we have a test that relied on an assumption about the number of spends in a
transaction that both minted and burned the same asset. we did not update this test to
reduce the number of spends in the transaction after changing the sdk behavior
to use minted value in outputs of a transaction

fixes the test by reducing the number of expected spends

changes 'Identifier' to 'Identity' to match logic changes

…4660)

* Add a one-time difficulty adjustment when FishHash activates

* pass in consensus directly instead of a bunch of consensus params

* move difficulty adjustment into a const

* removes duplicate check for duplicate name in createAccount

wallet.createAccount already checks for duplicate names

instead of checking in both RPC and wallet sdk, the RPC catches the error that
the wallet sdk throws and handles it with the appropriate RPC response

* updates test assertion for duplicate account name

* updating fixture

* non zero miner fee

* updating fixture

* resetting numberspush

* resetting numbers

* moving location of scan transactions to after account import

* update comment

…ments

The nonces/commitments are built from the secret share, the transaction
hash, and the list of signers, so they are unique per transaction and
they cannot be accidentally reused to sign multiple transactions.

* Creates a new signing package struct.

- Adds unsignedTransaction to the signing package.
- This new struct is passed between the rust/ typescript layer instead of the frost SigningPackage.
- This change has also led to simplification on the RPC and CLI side for creating signature shares.
- Removes the need to pass the transaction hash of the unsigned transaction

* removing duplicate try_deserialize_signersimport name

* lint fix

* removing unsigned transaction from aggregate signature share

* rust lint fix

This way, the list of signers does not have to be repeated in multiple
RPC calls.

…ansaction (#4745)

* feat(ironfish,rust,rust-nodejs): Return unsigned descriptions

* refactor(rust-nodejs): Lint

* Update PR feedback