Deprecate signPayload in favour of new createTransaction method from Signers

[ap211unitech]

More details here: https://hackmd.io/@arjun-porwal/SJwOGWWpex

[ap211unitech]

PoC code which I used for testing it:

import fs from "fs";
import { ApiPromise, Keyring, WsProvider } from "@polkadot/api";
import { AddressOrPair, Signer, SignerOptions } from "@polkadot/api/types";
import { TxPayloadV1 } from "@polkadot/types/types";
import { KeyringPair, KeyringPair$Json } from "@polkadot/keyring/types";
import { cryptoWaitReady } from "@polkadot/util-crypto";
import { HexString } from "@polkadot/util/types";
import { SignerPayload } from "@polkadot/types/interfaces";
import { GenericExtrinsic } from "@polkadot/types";
import { SubmittableExtrinsic } from "@polkadot/api/promise/types";

const MAIN_ACCOUNT = "5GLFKUxSXTf8MDDKM1vqEFb5TuV1q642qpQT964mrmjeKz4w";

export const signAndSubmit = async (
  extrinsic: SubmittableExtrinsic,
  address: AddressOrPair,
  options: Partial<SignerOptions>
) => {
  return await new Promise((resolve, reject) => {
    extrinsic
      .signAndSend(address, options, async (r) => {
        if (r.isError || r.internalError || r.dispatchError)
          reject(r.dispatchError?.toString() ?? r.internalError?.message);
        if (r.isInBlock) {
          const inBlockHash = r.status.asInBlock.toHex();

          console.log(`🎉 Tx finalizing with blockhash: ${inBlockHash}`);
          resolve("done");
        }
      })
      .catch((e) => {
        reject(e);
      });
  });
};

// Helper to extract 'extra' from extensions
const findExtra = (payloadV1: TxPayloadV1, id: string) => {
  const ext = payloadV1.extensions.find((e) => e.id === id);
  return ext && ext.extra !== "0x" ? ext.extra : null;
};

// Helper to extract 'additionalSigned' from extensions
const findAdditional = (payloadV1: TxPayloadV1, id: string) => {
  const ext = payloadV1.extensions.find((e) => e.id === id);
  return ext && ext.additionalSigned !== "0x" ? ext.additionalSigned : null;
};

async function setup() {
  await cryptoWaitReady();

  const api = await ApiPromise.create({
    provider: new WsProvider("wss://asset-hub-paseo.dotters.network"),
    noInitWarn: true,
  });

  await api.isReadyOrError;

  const keyring = new Keyring({ type: "sr25519" });

  const senderKeyring = keyring.addFromJson(
    JSON.parse(
      fs.readFileSync(`${MAIN_ACCOUNT}.json`, "utf-8")
    ) as KeyringPair$Json
  );
  senderKeyring.unlock("<your account password>");

  return { api, senderKeyring };
}

class MockModernSigner implements Signer {
  private readonly keypair: KeyringPair;
  private readonly api: ApiPromise;

  constructor(keypair: KeyringPair, api: ApiPromise) {
    this.keypair = keypair;
    this.api = api;
  }

  // 🎯 NEW METHOD: This function is the target of the new implementation
  public async createTransaction(payloadV1: TxPayloadV1): Promise<HexString> {
    const bestBlockHeight = payloadV1.context.bestBlockHeight;

    const blockHash = (
      await this.api.rpc.chain.getBlockHash(bestBlockHeight)
    ).toHex();

    const payloadToSign = this.api.registry.createType<SignerPayload>(
      "SignerPayload",
      {
        address: payloadV1.signer,
        blockHash,
        blockNumber: bestBlockHeight,
        era: findExtra(payloadV1, "CheckMortality"),
        genesisHash: findAdditional(payloadV1, "CheckGenesis"),
        method: payloadV1.callData,
        mode: null,
        nonce: findExtra(payloadV1, "CheckNonce"),
        runtimeVersion: this.api.runtimeVersion,
        signedExtensions: payloadV1.extensions.map((e) => e.id),
        tip: findExtra(payloadV1, "ChargeTransactionPayment"),
        assetId: findExtra(payloadV1, "ChargeAssetTxPayment"),
        version: findAdditional(payloadV1, "CheckTxVersion"),
      }
    );

    const { signature: signatureHex } = this.api.registry
      .createType("ExtrinsicPayload", payloadToSign.toPayload(), {
        version: payloadToSign.version,
      })
      .sign(this.keypair);

    const extrinsic = new GenericExtrinsic(
      this.api.registry,
      payloadToSign.method
    );

    extrinsic.addSignature(
      payloadV1.signer,
      signatureHex,
      payloadToSign.toPayload()
    );

    console.log("Signing successful...Submitting now..✅");

    return extrinsic.toHex();
  }
}

const main = async () => {
  const { api, senderKeyring } = await setup();

  console.log("Connected to API...🚀");

  const modernSigner = new MockModernSigner(senderKeyring, api);

  const ext = api.tx.balances.transferKeepAlive(
    "16kVKdv56dtV13tPttUZonKgj7qqkJget5Xkf3yMqEgdwhZK",
    1 * 10 ** 10 // 1 PAS
  );

  await signAndSubmit(ext, senderKeyring.address, { signer: modernSigner });

  await api.disconnect();
};

main()
  .catch((e) => console.log("Something went wrong!", e))
  .finally(() => process.exit(0));

Note: You must have to export your account as JSON file, and enter the password to unlock it in the script.

[ap211unitech]

Hi @josepot, could you please review this as well?
Just a heads-up — I'm on leave until December 8th, so I'll be able to address any feedback only after that.