import {Keypair} from '@stellar/stellar-sdk';

// Initialize with the wallet's Stellar address
const address = <the wallet's stellar address>;
const keypair = Keypair.fromPublicKey(address);

// Prepare the hash for signing
const hash = '0x6503b027a625549f7be691646404f275f149d17a119a6804b855bac3030037aa';

// Obtain the raw signature from Privy's raw_sign endpoint
const rawSignature = ... // call privy raw_sign on `hash`

// Verify the signature
const hashBytes = Buffer.from(hash.slice(2), 'hex');
const signatureBytes = Buffer.from(rawSignature.slice(2), 'hex');
const verified = keypair.verify(hashBytes, signatureBytes);
console.log(verified); // true

import { Secp256k1, Secp256k1Signature } from "@cosmjs/amino";

// Prepare the hash for signing
const hash = '0x6503b027a625549f7be691646404f275f149d17a119a6804b855bac3030037aa';

// Obtain the raw signature from Privy's raw_sign endpoint
const rawSignature = ... // call privy raw_sign on `hash`

// Retrieve the wallet's public key from Privy
const publicKey = ... // the wallet's public key from Privy

// Verify the signature
const signatureBytes = Secp256k1Signature.fromFixedLength(
  Buffer.from(rawSignature.slice(2), "hex")
);

const verified = await Secp256k1.verifySignature(
  signatureBytes,
  Buffer.from(hash.slice(2), "hex"),
  Buffer.from(publicKey, "hex")
);
console.log("Signature valid?", verified); // true

import {
  messageWithIntent,
  toSerializedSignature,
} from "@mysten/sui/cryptography";
import { blake2b } from "@noble/hashes/blake2b";
import { verifyTransactionSignature } from "@mysten/sui/verify";
// After you've added the data to your transaction
const txBytes = await tx.build({ client });
const intentMessage = messageWithIntent("TransactionData", txBytes);
const digest = blake2b(intentMessage, { dkLen: 32 });

// Convert the digest to a hex string for signing
const hashToSign = '0x' + toHex(digest);

// Obtain the raw signature from Privy's raw_sign endpoint
const rawSignature = ... // call privy raw_sign on `hashToSign`

// Create and verify the transaction signature
const txSignature = toSerializedSignature({
signature: rawSignature,
signatureScheme: "ED25519",
publicKey,
});
const signer = await verifyTransactionSignature(txBytes, txSignature, {address});
console.log(signer.toSuiAddress() === address); // true

import { TronWeb } from "tronweb";
import { hashMessage } from "tronweb/utils";

// Initialize with the wallet's Tron address
const address = <the wallet's tron address>;

// Determine the recovery ID for signature verification
const getRecoveryId = async ({
  message,
  rawSignature,
}: {
  message: string;
  rawSignature: string;
}) => {
  return (await tronWeb.trx.verifyMessageV2(message, rawSignature + '1b')) === address
    ? '1b'
    : '1c';
};

// Initialize TronWeb
const tronWeb = new TronWeb({
  fullHost: "xxx",
});

// Prepare and sign the message
const message = "Hello world";
const hash = hashMessage(message);

// Obtain the raw signature from Privy's raw_sign endpoint
const rawSignature = ... // call privy raw_sign on `hash`

// Verify the signature with the recovery ID
const signerAddress = await tronWeb.trx.verifyMessageV2(
  message,
  signature + (await getRecoveryId({message, rawSignature})
);
console.log(signerAddress === address); // true

import { p2pkh, OutScript } from "@scure/btc-signer/payment";
import {
  getInputType,
  getPrevOut,
  Transaction,
} from "@scure/btc-signer/transaction";
import { concatBytes } from "@scure/btc-signer/utils";
import secp256k1 from "secp256k1";

const publicKey = <the wallet's public key>;

const publicKeyBuffer = Buffer.from(publicKey, "hex");
const tx = new Transaction({ version: 1, allowLegacyWitnessUtxo: true });
// add as many outputs as needed, in this example there is only one
tx.addOutputAddress(outputAddress, outputAmount);

tx.addInput({
  txid, // buffer of utxo txid
  index: 0, // index of the output in the tx
  witnessUtxo: {
    amount: inputAmount,
    script: p2pkh(publicKeyBuffer).script,
  },
});

for (let i = 0; i < tx.inputsLength; i++) {
  const input = tx.getInput(i);
  const inputType = getInputType(input, tx.opts.allowLegacyWitnessUtxo);
  const prevOut = getPrevOut(input);
  let script = inputType.lastScript;
  if (inputType.last.type === "wpkh") {
    script = OutScript.encode({ type: "pkh", hash: inputType.last.hash });
  }
  const hash = tx.preimageWitnessV0(
    i,
    script,
    inputType.sighash,
    prevOut.amount
  );

const signature = // call Privy's raw sign function with bytesToHex(hash), returns '0x...'

  // convert to DER format
  const derSig = secp256k1.signatureImport(signature);
  tx.updateInput(
    i,
    {
      partialSig: [
        [publicKeyBuffer, concatBytes(derSig, new Uint8Array([inputType.sighash]))],
      ],
    },
    true
  );
}

tx.finalize();
return tx;