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/crypto';

// 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, PublicKey} from '@mysten/sui/cryptography';
import {blake2b} from '@noble/hashes/blake2b';
import {Transaction} from '@mysten/sui/transactions';
import {verifyTransactionSignature, publicKeyFromRawBytes} from '@mysten/sui/verify';
import {toHex} from '@mysten/sui/utils';
import {getFullnodeUrl, SuiClient} from '@mysten/sui/client';
import {base58} from '@scure/base';

// see Network Interactions with SuiClient for more info on creating clients
const client = new SuiClient({url: getFullnodeUrl('testnet')});
const tx = new Transaction();
// ... add some transactions...
const bytes = await tx.build({client});

const intentMessage = messageWithIntent('TransactionData', bytes);
const digest = blake2b(intentMessage, {dkLen: 32});

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

const address = '';
// get public key from privy wallet and decode to Uint8Array
const publicKey = publicKeyFromRawBytes('ED25519', base58.decode('<public key string>'));

// Obtain the raw signature from Privy's raw_sign endpoint
// call privy raw_sign on `hashToSign` and decode as Uint8Array
const rawSignature = new Uint8Array();

// Create and verify the transaction signature
const txSignature = toSerializedSignature({
  signature: rawSignature,
  signatureScheme: 'ED25519',
  publicKey
});
const signer = await verifyTransactionSignature(bytes, 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,
  rawSignature + (await getRecoveryId({message, rawSignature}))
);
console.log(signerAddress === address); // true

import {TronWeb, Types} from 'tronweb';

const tronWeb = new TronWeb({
  fullHost: 'https://api.shasta.trongrid.io'
});

const walletId = "<wallet's wallet ID>";

const from = "<wallet's tron address>";
const to = "<recipient's tron address>";
const amount = 1;

const tx = (await tronWeb.transactionBuilder.sendTrx(
  to,
  amount,
  from
)) as Types.SignedTransaction<Types.TransferContract>;

const rawTxBytes = tronWeb.utils.code.hexStr2byteArray(tx.txID);
const rawTxHex = '0x' + tronWeb.utils.code.byteArray2hexStr(rawTxBytes);

const signature = '...'; // call Privy's raw sign function with rawTxHex, returns '0x...'
(tx as Types.SignedTransaction<Types.TransferContract>).signature = [signature + '1b'];
if (tronWeb.trx.ecRecover(tx) !== from) {
  (tx as Types.SignedTransaction<Types.TransferContract>).signature = [signature + '1c'];
}

const result = await tronWeb.trx.sendRawTransaction(tx);
console.log('result', result);

import {p2wpkh, OutScript, getInputType, Transaction} from '@scure/btc-signer';
import {getPrevOut} from '@scure/btc-signer/transaction.js';
import {concatBytes} from '@scure/btc-signer/utils.js';
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
// note that the relay fee is sum(input amounts) - sum(output amounts)
const outputAddress = '';
const outputAmount = 0n;
tx.addOutputAddress(outputAddress, outputAmount);

const inputAmount = 0n;
tx.addInput({
  txid: '', // buffer of utxo txid
  index: 0, // index of the output in the tx
  witnessUtxo: {
    amount: inputAmount, // this must match the amount of the input exactly
    script: p2wpkh(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;
  // P2WPKH sighash uses the "pkh" script for signing
  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...'
  const signatureBuffer = Buffer.from(signature.slice(2), 'hex');
  // convert to DER format
  const derSig = secp256k1.signatureExport(signatureBuffer);
  tx.updateInput(
    i,
    {
      partialSig: [[publicKeyBuffer, concatBytes(derSig, new Uint8Array([inputType.sighash]))]]
    },
    true
  );
}

tx.finalize();
// return tx

import {utils, transactions, providers} from 'near-api-js';
import {sha256} from '@noble/hashes/sha256';
import {base58} from '@scure/base';
import {toHex} from 'viem';

const nodeUrl = 'https://rpc.mainnet.near.org';
const provider = new providers.JsonRpcProvider({url: nodeUrl});
const receiverId = 'receiver.near';
const amount = '1.5';
const nonce = 0; // If this is not the wallet's first transaction, set as current nonce

const {
  header: {hash}
} = await provider.block({finality: 'final'});
const blockHash = utils.serialize.base_decode(hash);

const accountId = "<wallet's near-implicit address / account ID>";

const base58PublicKey = base58.encode(Buffer.from(accountId, 'hex'));
const publicKey = utils.PublicKey.fromString(`ed25519:${base58PublicKey}`);

const amountYocto = utils.format.parseNearAmount(amount);
const actions = [transactions.transfer(BigInt(amountYocto ?? 0))];
const tx = transactions.createTransaction(
  accountId,
  publicKey,
  receiverId,
  nonce,
  actions,
  blockHash
);

const serializedTx = utils.serialize.serialize(transactions.SCHEMA.Transaction, tx);

const txHash = toHex(sha256(serializedTx));

const signature = '...'; // call Privy's raw sign function with txHash, returns '0x...'

const signedTx = new transactions.SignedTransaction({
  transaction: tx,
  signature: new transactions.Signature({
    keyType: tx.publicKey.keyType,
    data: Buffer.from(signature.slice(2), 'hex')
  })
});

const signedSerializedTx = signedTx.encode();
const result = await provider.sendJsonRpc('broadcast_tx_commit', [
  Buffer.from(signedSerializedTx).toString('base64')
]);

import {Cell, TonClient, WalletContractV4, internal} from '@ton/ton';
import {toHex} from 'viem';

// Create Client
const client = new TonClient({
  endpoint: 'https://toncenter.com/api/v2/jsonRPC'
});

const walletId = "<wallet's wallet ID>";
const publicKey = "<wallet's public key>";

const trimmedPublicKey = Buffer.from(publicKey.slice(2), 'hex');
// Create wallet contract
let workchain = 0; // Usually you need a workchain 0
let wallet = WalletContractV4.create({
  workchain,
  publicKey: trimmedPublicKey
});
let contract = client.open(wallet);

// Create a transfer
let seqno: number = await contract.getSeqno();
const transfer = await contract.createTransfer({
  seqno,
  messages: [
    internal({
      value: '1',
      to: 'to_address',
      body: 'Hello world'
    })
  ],
  signer: async (msg: Cell) => {
    let hash = msg.hash();
    let signature = '...'; // call Privy's raw sign function with toHex(hash), returns '0x...'
    return Buffer.from(signature.slice(2), 'hex');
  }
});

import {
  RpcProvider,
  SignerInterface,
  hash,
  CallData,
  CairoOption,
  CairoOptionVariant,
  CairoCustomEnum,
  Account,
  cairo,
  TypedData,
  Signature,
  Call,
  InvocationsSignerDetails,
  DeployAccountSignerDetails,
  DeclareSignerDetails
} from 'starknet';

// connect RPC 0.8 provider
const provider = new RpcProvider({
  nodeUrl: 'https://starknet-sepolia.public.blastapi.io/rpc/v0_8'
});

//new Argent X account v0.5.0
const ARGENT_X_ACCOUNT_CLASS_HASH_V0_5_0 =
  '0x073414441639dcd11d1846f287650a00c60c416b9d3ba45d31c651672125b2c2';

const publicKey = 'your public key';

// Calculate future address of the ArgentX account
const axSigner = new CairoCustomEnum({Starknet: {pubkey: publicKey}});
const axGuardian = new CairoOption<unknown>(CairoOptionVariant.None);
const AXConstructorCallData = CallData.compile({
  owner: axSigner,
  guardian: axGuardian
});
const AXcontractAddress = hash.calculateContractAddressFromHash(
  publicKey,
  ARGENT_X_ACCOUNT_CLASS_HASH_V0_5_0,
  AXConstructorCallData,
  0
);

// Use a RawSigner wrapper class around Signer. Example: https://github.com/argentlabs/argent-contracts-starknet/blob/6243bcf39fac0df25cff183056a9bc8f1e15ef28/lib/signers/signers.ts#L38
export abstract class RawSigner extends SignerInterface {
  abstract signRaw(messageHash: string): Promise<string[]>;

  public async getPubKey(): Promise<string> {
    throw new Error('Example');
  }

  public async signMessage(
    typedDataArgument: TypedData,
    accountAddress: string
  ): Promise<Signature> {
    throw new Error('Example');
  }

  public async signTransaction(
    transactions: Call[],
    details: InvocationsSignerDetails
  ): Promise<Signature> {
    throw new Error('Example');
  }

  public async signDeployAccountTransaction(
    details: DeployAccountSignerDetails
  ): Promise<Signature> {
    throw new Error('Example');
  }

  public async signDeclareTransaction(details: DeclareSignerDetails): Promise<Signature> {
    throw new Error('Example');
  }
}

const account = new Account(
  provider,
  AXcontractAddress,
  new (class extends RawSigner {
    public async signRaw(messageHash: string): Promise<string[]> {
      console.log('messageHash=', messageHash);
      // Get the signature using the privy raw sign method
      const sig = '..';
      const sigWithout0x = sig.slice(2);
      const r = `0x${sigWithout0x.slice(0, 64)}`;
      const s = `0x${sigWithout0x.slice(64)}`;
      return [r, s];
    }
  })()
);

// The account address must hold STRK tokens to deploy the account.

const accountDeployResult = await account.deployAccount({
  classHash: ARGENT_X_ACCOUNT_CLASS_HASH_V0_5_0,
  contractAddress: AXcontractAddress,
  constructorCalldata: AXConstructorCallData,
  addressSalt: publicKey
});

console.log('accountDeployResult=', accountDeployResult);

// Transfer 1 STRK unit to your recipient address
const STRK_TOKEN_ADDRESS = '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d';

const amount = cairo.uint256(1);

// Simple transfer call using account.execute
const transferCall = {
  contractAddress: STRK_TOKEN_ADDRESS,
  entrypoint: 'transfer',
  calldata: CallData.compile({
    recipient: 'your recipient address',
    amount: amount
  })
};

const result = await account.execute(transferCall);
await provider.waitForTransaction(result.transaction_hash);

import {
  Aptos,
  AptosConfig,
  Network,
  AccountAddress,
  AccountAuthenticatorEd25519,
  Ed25519PublicKey,
  Ed25519Signature,
  generateSigningMessageForTransaction
} from '@aptos-labs/ts-sdk';
import {toHex} from 'viem';

// 1) Wire up the client for the chain
const aptos = new Aptos(
  new AptosConfig({
    network: Network.MAINNET
    // To build a transaction for Movement Mainnet, use the following:
    // network: Network.MAINNET,
    // fullnode: "https://full.mainnet.movementinfra.xyz/v1",
  })
);
const walletId = '<wallet ID from Privy>';
const publicKey = '<public key of wallet>'; // 32-byte ed25519 public key hex
const address = AccountAddress.from('<wallet address>');

// 2) Build the raw transaction (SDK fills in seq#, chainId, gas if you let it)
const rawTxn = await aptos.transaction.build.simple({
  sender: address,
  data: {
    function: '0x1::coin::transfer',
    typeArguments: ['0x1::aptos_coin::AptosCoin'],
    functionArguments: ['<recipient address>', 1] // amount in Octas
  }
});

const message = generateSigningMessageForTransaction(rawTxn);

const signature = '...'; // call Privy's raw sign function with txHash, returns '0x...'

// 5) Wrap pk + signature in an authenticator and submit
const senderAuthenticator = new AccountAuthenticatorEd25519(
  new Ed25519PublicKey(publicKey),
  new Ed25519Signature(signature.slice(2))
);

const pending = await aptos.transaction.submit.simple({
  transaction: rawTxn,
  senderAuthenticator
});

const executed = await aptos.waitForTransaction({
  transactionHash: pending.hash
});
console.log('Executed:', executed.hash);

import {
  Aptos,
  AptosConfig,
  Network,
  AccountAddress,
  AccountAuthenticatorEd25519,
  Ed25519PublicKey,
  Ed25519Signature,
  generateSigningMessageForTransaction
} from '@aptos-labs/ts-sdk';
import {toHex} from 'viem';

// 1) Wire up the client for the Movement chain
const aptos = new Aptos(
  new AptosConfig({
    network: Network.TESTNET,
    fullnode: 'https://full.testnet.movementinfra.xyz/v1'
  })
);
const walletId = '<wallet ID from Privy>';
const publicKey = '<public key of wallet>'; // 32-byte ed25519 public key hex
const address = AccountAddress.from('<wallet address>');

// 2) Build the raw transaction (SDK fills in seq#, chainId, gas if you let it)
const rawTxn = await aptos.transaction.build.simple({
  sender: address,
  data: {
    function: '0x1::coin::transfer',
    typeArguments: ['0x1::aptos_coin::AptosCoin'],
    functionArguments: ['<recipient address>', 1] // amount in Octas
  }
});

const message = generateSigningMessageForTransaction(rawTxn);
const signature = await privy.wallets().rawSign(walletId, {params: {hash: toHex(message)}});

// 5) Wrap pk + signature in an authenticator and submit
const senderAuthenticator = new AccountAuthenticatorEd25519(
  new Ed25519PublicKey(publicKey),
  new Ed25519Signature(signature.slice(2))
);

const pending = await aptos.transaction.submit.simple({
  transaction: rawTxn,
  senderAuthenticator
});

const executed = await aptos.waitForTransaction({
  transactionHash: pending.hash
});
console.log('Executed:', executed.hash);