Signing Transactions

const btcRpcAdapter = new chainAdapters.btc.BTCRpcAdapters.Mempool(
  "https://mempool.space/testnet4/api",
);

const Bitcoin = new chainAdapters.btc.Bitcoin({
  network: NetworkId,
  btcRpcAdapter,
  contract: SIGNET_CONTRACT,
});

const connection = new SolanaConnection("https://api.devnet.solana.com");

const Solana = new chainAdapters.solana.Solana({
  solanaConnection: connection,
  contract: SIGNET_CONTRACT,
});

const Xrp = new chainAdapters.xrp.XRP({
  rpcUrl: "wss://s.altnet.rippletest.net:51233/",
  contract: SIGNET_CONTRACT,
});

const rpcUrl = getFullnodeUrl("testnet");
const suiClient = new SuiClient({ url: rpcUrl });

const Sui = new chainAdapters.sui.SUI({
  client: suiClient,
  contract: SIGNET_CONTRACT,
  rpcUrl: rpcUrl,
});

const aptosClient = new AptosClient(
  new AptosConfig({
    network: Network.TESTNET,
  }),
);

const Aptos = new chainAdapters.aptos.Aptos({
  client: aptosClient,
  contract: SIGNET_CONTRACT,
});

const { address, publicKey } = await Bitcoin.deriveAddressAndPublicKey(
  signedAccountId,
  debouncedDerivationPath,
);

const { publicKey } = await Solana.deriveAddressAndPublicKey(
  signedAccountId,
  debouncedDerivationPath,
);

const { address, publicKey } = await Xrp.deriveAddressAndPublicKey(
  signedAccountId,
  debouncedDerivationPath,
);

const { address, publicKey } = await Sui.deriveAddressAndPublicKey(
  signedAccountId,
  debouncedDerivationPath,
);

const { address, publicKey } = await Aptos.deriveAddressAndPublicKey(
  signedAccountId,
  debouncedDerivationPath,
);

const { transaction, hashesToSign } =
  await Bitcoin.prepareTransactionForSigning({
    publicKey: senderPublicKey,
    from: senderAddress,
    to: receiverAddress,
    value: transferAmount.toString(),
  });

const {
  transaction: { transaction },
  hashesToSign,
} = await Solana.prepareTransactionForSigning({
  from: senderAddress,
  to: receiverAddress,
  amount: decimalToBigInt(transferAmount, 9),
});

const { transaction, hashesToSign } =
  await Xrp.prepareTransactionForSigning({
    from: senderAddress,
    to: receiverAddress,
    amount: decimalToBigInt(transferAmount, 6).toString(),
    publicKey: senderPublicKey,
  });

const transactionSui = new Transaction();

const [coin] = transactionSui.splitCoins(transactionSui.gas, [
  decimalToBigInt(transferAmount, 9),
]);

transactionSui.transferObjects([coin], receiverAddress);
transactionSui.setSender(senderAddress);

const { hashesToSign, transaction } =
  await Sui.prepareTransactionForSigning(transactionSui);

const transactionPayload = {
  function: "0x1::aptos_account::transfer",
  functionArguments: [receiverAddress, decimalToBigInt(transferAmount, 8)],
};

const transaction = await aptosClient.transaction.build.simple({
  sender: senderAddress,
  data: transactionPayload,
});

const { hashesToSign } =
  await Aptos.prepareTransactionForSigning(transaction);

const rsvSignatures = await SIGNET_CONTRACT.sign({
  payloads: hashesToSign,
  path: debouncedDerivationPath,
  keyType: "Ecdsa",
  signerAccount: {
    accountId: signedAccountId,
    signAndSendTransactions,
  },
});

const rsvSignatures = await SIGNET_CONTRACT.sign({
  payloads: hashesToSign,
  path: debouncedDerivationPath,
  keyType: "Eddsa",
  signerAccount: {
    accountId: signedAccountId,
    signAndSendTransactions,
  },
});

const rsvSignatures = await SIGNET_CONTRACT.sign({
  payloads: hashesToSign,
  path: debouncedDerivationPath,
  keyType: "Ecdsa",
  signerAccount: {
    accountId: signedAccountId,
    signAndSendTransactions,
  },
});

const rsvSignatures = await SIGNET_CONTRACT.sign({
  payloads: hashesToSign,
  path: debouncedDerivationPath,
  keyType: "Eddsa",
  signerAccount: {
    accountId: signedAccountId,
    signAndSendTransactions,
  },
});

const rsvSignatures = await SIGNET_CONTRACT.sign({
  payloads: hashesToSign,
  path: debouncedDerivationPath,
  keyType: "Eddsa",
  signerAccount: {
    accountId: signedAccountId,
    signAndSendTransactions,
  },
});

const finalizedTransaction = Bitcoin.finalizeTransactionSigning({
  transaction,
  rsvSignatures,
});

const finalizedTransaction = Solana.finalizeTransactionSigning({
  transaction,
  rsvSignatures: rsvSignatures[0],
  senderAddress,
});

const finalizedTransaction = Xrp.finalizeTransactionSigning({
  transaction,
  rsvSignatures,
});

const finalizedTransaction = Sui.finalizeTransactionSigning({
  transaction,
  rsvSignatures: rsvSignatures[0],
  publicKey: senderPublicKey,
});

const finalizedTransaction = Aptos.finalizeTransactionSigning({
  transaction,
  rsvSignatures: rsvSignatures[0],
  publicKey: senderPublicKey,
});

const transactionHash = await Bitcoin.broadcastTx(signedTransaction);

const transactionHash = await Solana.broadcastTx(signedTransaction);

const transactionHash = await Xrp.broadcastTx(signedTransaction);

const transactionHash = await Sui.broadcastTx(signedTransaction);

const transactionHash = await Aptos.broadcastTx(signedTransaction);