Tier 1 wallet integration

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 {p2tr} from '@scure/btc-signer/payment';
import {Transaction, getInputType, getPrevOut} from '@scure/btc-signer/transaction';

// The wallet's `public_key` from the Privy Wallet object (33-byte compressed secp256k1 key, hex)
const publicKey = wallet.public_key;

// Extract the 32-byte x-only public key (strip the compression prefix byte)
const pubKeyBytes = Buffer.from(publicKey, 'hex');
const xOnlyPubKey = pubKeyBytes.subarray(1);

// Build the P2TR output for this wallet
const taprootOutput = p2tr(xOnlyPubKey);

const tx = new Transaction({allowLegacyWitnessUtxo: true});

// Add outputs
const outputAddress = '';
const outputAmount = 0n;
tx.addOutputAddress(outputAddress, outputAmount);

// Add a taproot input
const inputAmount = 0n;
tx.addInput({
  txid: '', // buffer of UTXO txid
  index: 0, // index of the output in the funding tx
  witnessUtxo: {
    amount: inputAmount, // must match the UTXO amount exactly
    script: taprootOutput.script
  },
  tapInternalKey: xOnlyPubKey
});

for (let i = 0; i < tx.inputsLength; i++) {
  const input = tx.getInput(i);
  const inputType = getInputType(input, true);
  const prevOut = getPrevOut(input);

  // Compute the BIP-341 sighash (witness v1)
  const sighash = tx.preimageWitnessV1(i, [prevOut.script], inputType.sighash, [prevOut.amount]);

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

  // Attach the 64-byte Schnorr signature as tapKeySig
  const signatureBytes = Buffer.from(signature.slice(2), 'hex');
  tx.updateInput(i, {tapKeySig: signatureBytes}, true);
}

// finalize() validates the Schnorr signature against the tweaked output key
tx.finalize();

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 {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);