Creating transactions and signing them offline

const transactionSchema = {
  $id: '/lisk/transaction',
  type: 'object',
  required: ['module', 'command', 'nonce', 'fee', 'senderPublicKey', 'params'],
  properties: {
    module: {
      dataType: 'string',
      fieldNumber: 1,
      minLength: 1,
      maxLength: 32,
    },
    command: {
      dataType: 'string',
      fieldNumber: 2,
      minLength: 1,
      maxLength: 32,
    },
    nonce: {
      dataType: 'uint64',
      fieldNumber: 3,
    },
    fee: {
      dataType: 'uint64',
      fieldNumber: 4,
    },
    senderPublicKey: {
      dataType: 'bytes',
      fieldNumber: 5,
      minLength: 32,
      maxLength: 32,
    },
    params: {
      dataType: 'bytes',
      fieldNumber: 6,
    },
    signatures: {
      type: 'array',
      items: {
        dataType: 'bytes',
      },
      fieldNumber: 7,
    },
  },
};

const transferParamsSchema = {
  $id: '/lisk/transferParams',
  title: 'Transfer transaction params',
  type: 'object',
  required: ['tokenID', 'amount', 'recipientAddress', 'data'],
  properties: {
    tokenID: {
      dataType: 'bytes',
      fieldNumber: 1,
      minLength: 8,
      maxLength: 8,
    },
    amount: {
      dataType: 'uint64',
      fieldNumber: 2,
    },
    recipientAddress: {
      dataType: 'bytes',
      fieldNumber: 3,
      format: 'lisk32',
    },
    data: {
      dataType: 'string',
      fieldNumber: 4,
      minLength: 0,
      maxLength: 64,
    },
  },
};

{
  "address": "lskg6prjbqpm6m8rsvmsg6dgyx3e89drknbvxg7x8",
  "keyPath": "m/44'/134'/0'",
  "publicKey": "ec10255d3e78b2977f04e59ea9afd3e9a2ce9a6b44619ef9f6c47c29695b1df3",
  "privateKey": "ac3e34eb369d52a3cddf0bc4312d9b0aa3625b04721039bb114f4c607fb5256eec10255d3e78b2977f04e59ea9afd3e9a2ce9a6b44619ef9f6c47c29695b1df3",
  "binaryAddress": "85c12d39041bc09e1f89dfeffe4b87cfcfe79fb2"
}

const { validator } = require('@liskhq/lisk-client');
const { transactionSchema } = require('../schemas');
// Example account credentials
const account = require('./account.json');

const createTxOffline = () => {
	// Adjust the values of the unsigned transaction manually
	const unsignedTransaction = {
		module: "token",
		command: "transfer",
		fee: BigInt(10000000),
		nonce: BigInt(23),
		senderPublicKey: Buffer.from(account.publicKey,'hex'),
		params: Buffer.alloc(0),
		signatures: [],
	};

	// Validate the transaction
	const transactionErrors = validator.validator.validate(transactionSchema, unsignedTransaction);

	if (transactionErrors && transactionErrors.length) {
		throw new validator.LiskValidationError([...transactionErrors]);
	}

	// Create the asset for the Token Transfer transaction
	const transferParams = {
		tokenID: Buffer.from('0000000000000000','hex'),
		amount: BigInt(2000000000),
		recipientAddress: Buffer.from(account.binaryAddress,'hex'),
		data: 'Happy birthday!'
	};

	// Add the transaction params to the transaction object
	unsignedTransaction.params = transferParams;

	// Return the unsigned transaction object
	return unsignedTransaction;
}

module.exports = { createTxOffline }

const { transactions } = require('@liskhq/lisk-client');
const { transferParamsSchema } = require('../schemas');
const account = require('./account.json');

const chainID = '00000000';

const signTx = (unsignedTransaction) => {
	const signedTransaction = transactions.signTransaction(
		unsignedTransaction,
		Buffer.from(chainID, 'hex'),
		Buffer.from(account.privateKey,'hex'),
		transferParamsSchema
	);

	return signedTransaction;
}


module.exports = { signTx }

const { apiClient } = require('@liskhq/lisk-client');

// Adjust the RPC_ENDPOINT to point to your RPC node, if required.
const RPC_ENDPOINT = 'ws://localhost:7887/rpc-ws';
let clientCache;

const getClient = async () => {
  if (!clientCache) {
    clientCache = await apiClient.createWSClient(RPC_ENDPOINT);
  }
  return clientCache;
};

module.exports = { getClient };

const { getClient } = require('../api-client');

const dryRun = async (signedTransaction) => {
	const client = await getClient();
	const encTx = client.transaction.encode(signedTransaction);
	const result = await client.invoke('txpool_dryRunTransaction', { "transaction": encTx.toString("hex") });

	return result;
}

module.exports = { dryRun };

const { createTxOffline } = require('./create-offline');
const { signTx } = require('./sign-offline');
const { dryRun } = require('./dry-run');

(async () => {
    // 1. Create an unsigned transaction
	const tx = createTxOffline();
	console.log("Unsigned Transaction: ", tx);

    // 2. Sign the transaction
	const signedTx = signTx(tx);
	console.log("Signed Transaction: ", signedTx);

    // 3. Perform a dry-run for the signed transaction
	const dryRunResult = await dryRun(signedTx)
	console.log("Dry-Run Result: ", dryRunResult);

	process.exit(0);
})();

{
  module: 'token',
  command: 'transfer',
  fee: 10000000n,
  nonce: 23n,
  senderPublicKey: <Buffer ec 10 25 5d 3e 78 b2 97 7f 04 e5 9e a9 af d3 e9 a2 ce 9a 6b 44 61 9e f9 f6 c4 7c 29 69 5b 1d f3>,
  params: {
    tokenID: <Buffer 00 00 00 00 00 00 00 00>,
    amount: 2000000000n,
    recipientAddress: <Buffer 85 c1 2d 39 04 1b c0 9e 1f 89 df ef fe 4b 87 cf cf e7 9f b2>,
    data: 'Happy birthday!'
  },
  signatures: []
}

{
  module: 'token',
  command: 'transfer',
  fee: 10000000n,
  nonce: 23n,
  senderPublicKey: <Buffer ec 10 25 5d 3e 78 b2 97 7f 04 e5 9e a9 af d3 e9 a2 ce 9a 6b 44 61 9e f9 f6 c4 7c 29 69 5b 1d f3>,
  params: {
    tokenID: <Buffer 00 00 00 00 00 00 00 00>,
    amount: 2000000000n,
    recipientAddress: <Buffer 85 c1 2d 39 04 1b c0 9e 1f 89 df ef fe 4b 87 cf cf e7 9f b2>,
    data: 'Happy birthday!'
  },
  signatures: [
    <Buffer cd 28 ce 82 43 67 7b 16 a5 b9 f1 9b 6d 71 58 c0 bb b2 c9 9f 11 dc 25 34 96 d2 6a 14 d4 1c a6 03 d0 ab 49 67 4a 1c ee df aa a7 36 8e d0 1b a3 fa e2 81 ... 14 more bytes>
  ],
  id: <Buffer be 19 fd 1d e0 29 d0 78 e8 03 bb fb b0 8e bc 70 d1 34 e8 c1 d1 37 1f 0a 65 b5 7b 3d 76 9a 45 37>
}

{
  result: 0,
  events: [
    {
      data: '0a14fa892e1aa42a8af96c45dfd5afc428b3dba950e612036665651a0803000008000000002080ade2042800',
      index: 0,
      module: 'token',
      name: 'lock',
      topics: [Array],
      height: 12636
    },
    {
      data: '0a14fa892e1aa42a8af96c45dfd5afc428b3dba950e612036665651a0803000008000000002080ade2042800',
      index: 1,
      module: 'token',
      name: 'unlock',
      topics: [Array],
      height: 12636
    },
    {
      data: '0a14fa892e1aa42a8af96c45dfd5afc428b3dba950e61208030000080000000018c89cbc022000',
      index: 2,
      module: 'token',
      name: 'burn',
      topics: [Array],
      height: 12636
    },
    {
      data: '0a14fa892e1aa42a8af96c45dfd5afc428b3dba950e61214821a6aa707422e6d444b42afb2a303d014d620221a08030000080000000020b890a6022800',
      index: 3,
      module: 'token',
      name: 'transfer',
      topics: [Array],
      height: 12636
    },
    {
      data: '0a14fa892e1aa42a8af96c45dfd5afc428b3dba950e61214821a6aa707422e6d444b42afb2a303d014d6202218c89cbc0220b890a602',
      index: 4,
      module: 'fee',
      name: 'generatorFeeProcessed',
      topics: [Array],
      height: 12636
    },
    {
      data: '0800',
      index: 5,
      module: 'token',
      name: 'commandExecutionResult',
      topics: [Array],
      height: 12636
    }
  ]
}