Implement getTransactionId for transfers on the Predicate class

[arboleya]

Given this example:

// Prepare the transaction.
const tx = await state.predicate
    .transfer(recipient, value, types.BaseAssetId, {
        gasPrice: 1,
        gasLimit: 3_500_000,
});

// Wait for result.
const result = await tx.waitForResult();

One might need to get the transaction ID before sending the transaction:

// Getting chain Id
const chainId = provider.getChainId();

// Get tx ID
const txId = hashTransaction(txRequest, chainId); // <— like this

// Sending the tx to the chain
const tx = await myWallet.sendTransaction(txRequest);

// Waiting for the tx to be processed
const res = await tx.waitForResult();

The problem is that the transfer method creates a ScriptTransactionRequest, funds it, and sends in the same call.

To intercept the request and compute the transaction ID before it's sent, we must fragment this chain-of-action and expose the request instance in isolation via a method utility or something similar, enabling one to modify it before submitting the transaction and even getTransactionId() before calling submit().

From this:

predicate.transfer(...);

To something like this:

// first iteration
const txID = predicate.getTransactionId();
predicate.transfer(...);

And then this:

// second iteration
const transfer = predicate.transfer(...);
const txID = transfer.getTransactionId()

transfer.submit(...);

Warning

Remember to roll this update in two phases:

1. Add method getTransferTransactionId() and keep transfer() as is, but with a deprecation notice

   • No breaking changes here; annotate deprecations.

2. Implement .transfer().getTransactionId().submit()

   • Possible breaking changes; may apply deprecations.

[arboleya]

Although adding this getTransactionId method will be handy, we should improve the Predicate DX afterward via:

• Improve DX for Predicate class #1457

If Predicate had the same DX as Contract, we could do something like this:

const transaction = contract.functions
  .transfer(amountToTransfer, BaseAssetId, someAddress)
  .callParams({
    forward: [amountToForward, BaseAssetId],
  })
  .txParams({
    gasPrice: 1,
    gasLimit: 1,
    variableOutputs: 1,
  });
​
const request = await transaction.getTransactionRequest();
​
// before sending
console.log('gasLimit: ', request.gasLimit);
console.log('gasPrice: ', request.gasPrice);
console.log('Tx ID: ', hashTransaction(request, 0));
​
// sending
const { gasUsed } = await transaction.call();
​
// after sending
console.log({ gasUsed });

[arboleya]

Either way, instead of getting the TX ID like this:

const transaction = contract.functions.xyz();
const request = await transaction.getTransactionRequest();
const txID = hashTransaction(request, 0);

We could have something more straightforward:

const transaction = contract.functions.xyz();
const txID = transaction.getTransactionId();

This would eliminate the need to use hashTransaction manually.

This rationale applies to both Contract and Predicate classes.

[arboleya]

No required but related:

• Tool for Automated API Migration and Deprecation Handling #1464