Crypto wallet steps manually

Wallets are applications that appear as black boxes to users. However, if you grasp the basic concept of how wallets operate, you can handle their functions yourself.

The wallet function comprises four main steps: Address (keys pair) Generation, Transaction Preparation, Signing the Prepared Transaction, and Broadcasting the Transaction.

By independently performing these steps instead of relying on “black box” apps, you can exercise greater control over the security and privacy of your assets.

Out of the four main functions mentioned, only two of them require interaction with a node (an internet connection): Transaction Preparation and Broadcasting the Transaction. The other two can be performed offline.

It is possible to perform various steps of wallet operations manually without relying on a specific wallet software. This approach allows for more granular control over the process and can be useful in certain scenarios. Here’s a breakdown of the steps:

1. Address Generation: Generating a new address does not require an internet connection or interaction with a node. You can use cryptographic libraries to generate a new private key and derive the corresponding public key and address. This can be done offline using appropriate algorithms and libraries.
2. Transaction Preparation: To prepare a transaction, you need information about the current state of the relevant address, such as the number of inputs and outputs. You can obtain this information by querying a blockchain explorer or by using utilities or libraries that allow you to inspect the blockchain’s transaction history for a specific address. This step typically requires an internet connection.
3. Signing the Prepared Transaction: Signing the transaction requires access to the private key associated with the input addresses. Using cryptographic libraries and the private key, you can sign the raw transaction offline without needing an internet connection or node interaction.

Broadcasting the Transaction: Once the transaction is signed, it needs to be broadcasted to the network for inclusion in a block. Broadcasting can be done by using any available blockchain node or service that accepts transaction submissions. This step requires an internet connection to connect to a node that will propagate the transaction across the network.
By performing these steps manually, you have more control over the wallet operations and can tailor the process to your specific needs. However, it requires a deeper understanding of the underlying protocols, cryptography, and data structures involved in wallet operations.

Let’s talk about first step — Address Generation.

Below you can see the JS code snippets — of how to generate three (just for sample — three, you can set any number of address you need).

The input for the code (located in .env file) — is mnemonic phrase (be aware of mnemonic rule — it is not a just any random english world)

require('dotenv').config();
const bip39 = require('bip39');
const hdkey = require('hdkey');
const bitcoin = require('bitcoinjs-lib');
const mnemonic = process.env.MNEMONIC;
const seed = bip39.mnemonicToSeedSync(mnemonic);
const root = hdkey.fromMasterSeed(seed);
const path = "m/44'/0'/0'/0";
const child = root.derive(path);
console.log(`BIP32 Extended Private Key: ${child.privateExtendedKey}\n`);
const network = bitcoin.networks.bitcoin;
for (let i = 0; i < 3; i++) {
  const derivedPath = `${path}/${i}`;
  const derivedChild = root.derive(derivedPath);
  const { address } = bitcoin.payments.p2pkh({ pubkey: derivedChild.publicKey, network });
  const privateKey = derivedChild.privateKey.toString('hex');
  console.log(`Address ${i + 1}: ${address}`);
  console.log(`Private Key ${i + 1}: ${privateKey}\n`);
}

Once run the snippets — you will get to your console three generated pare of addresses and the private keys in Hex format.

To convert the private keys Hex format to WIF format — you can use this snipets:

function privateKeyToWIF(privateKey) {
    const prefix = Buffer.from([0x80]); // Mainnet prefix
    const suffix = Buffer.from([0x01]); // Compressed suffix

    const extendedPrivateKey = Buffer.concat([prefix, privateKey, suffix]);
    const checksum = sha256(sha256(extendedPrivateKey)).slice(0, 4);
    const extendedPrivateKeyChecksum = Buffer.concat([extendedPrivateKey, checksum]);

    const wif = base58Encode(extendedPrivateKeyChecksum);
    return wif;
  }

  function sha256(buffer) {
    const crypto = require('crypto');
    return crypto.createHash('sha256').update(buffer).digest();
  }

  function base58Encode(buffer) {
    const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    const BASE = BigInt(ALPHABET.length);

    let leadingZeros = 0;
    while (buffer[leadingZeros] === 0x00) {
      leadingZeros++;
    }

    let num = BigInt('0x' + buffer.toString('hex'));
    let encoded = '';

    while (num > 0) {
      const remainder = num % BASE;
      num = num / BASE;
      encoded = ALPHABET[Number(remainder)] + encoded;
    }

    return '1'.repeat(leadingZeros) + encoded;
  }

  // Usage example
  const privateKeyHex = 'put here your key in HEX format';
  const privateKeyBuffer = Buffer.from(privateKeyHex, 'hex');
  const privateKeyWIF = privateKeyToWIF(privateKeyBuffer);

  console.log(`Private Key (Hexadecimal): ${privateKeyHex}`);
  console.log(`Private Key (WIF): ${privateKeyWIF}`);

That it for today, if you like the content please “Like it”, and in next we will talk about step 2 — Transaction Preparation.