@chainberry/berry-signer 1.0.0

package/README.md

@@ -0,0 +1,117 @@
+# BerrySigner
+
+Pure signing library for multiple blockchain networks. No network calls — takes an unsigned transaction prepared elsewhere and signs it locally with a private key. Designed to run on the frontend (mobile wallet, browser extension) while the unsigned transaction is prepared on the backend.
+
+## Installation
+
+```sh
+npm install berry-signer
+```
+
+## Supported Chains
+
+| Chain | Function |
+|-------|----------|
+| EVM (ETH, BNB, POL, AVAX, ARB, OP, BASE, SONIC) | `signEvmTransaction` |
+| Bitcoin | `signBtcTransaction` |
+| Litecoin | `signLtcTransaction` |
+| Solana | `signSolTransaction` |
+| TRON | `signTrxTransaction` |
+| XRP Ledger | `signXrpTransaction` |
+| TON | `signTonTransaction` |
+
+## Usage
+
+Each function takes a private key and an unsigned transaction prepared by the backend, and returns a signed transaction ready for broadcast.
+
+### EVM (ETH, BNB, POL, AVAX, ARB, OP, BASE, SONIC)
+
+```ts
+import { signEvmTransaction } from "berry-signer";
+
+const signedTx = await signEvmTransaction(privateKeyHex, unsignedTx);
+// signedTx is a hex string ready to broadcast via eth_sendRawTransaction
+```
+
+### Bitcoin
+
+```ts
+import { signBtcTransaction } from "berry-signer";
+
+const signedTxHex = signBtcTransaction(privateKeyHex, unsignedPsbtBase64, isMainnet);
+// signedTxHex is a raw transaction hex ready for broadcast
+```
+
+### Litecoin
+
+```ts
+import { signLtcTransaction } from "berry-signer";
+
+const signedTxHex = signLtcTransaction(privateKeyHex, unsignedPsbtBase64, isMainnet);
+```
+
+### Solana
+
+```ts
+import { signSolTransaction } from "berry-signer";
+
+const signedTxBase64 = signSolTransaction(privateKey, unsignedTxBase64);
+// signedTxBase64 is a base64-encoded signed transaction
+```
+
+### TRON
+
+```ts
+import { signTrxTransaction } from "berry-signer";
+
+const signedTxJson = await signTrxTransaction(privateKey, unsignedTx, rpcUrl);
+// signedTxJson is a JSON string of the signed transaction
+```
+
+### XRP Ledger
+
+```ts
+import { signXrpTransaction } from "berry-signer";
+
+const signedTxBlob = signXrpTransaction(privateKeyHex, preparedTx);
+// signedTxBlob is a hex-encoded signed transaction blob
+```
+
+### TON
+
+```ts
+import { signTonTransaction } from "berry-signer";
+
+const { bocBase64, txHash } = signTonTransaction(privateKeyHex, {
+  toAddress,
+  amount,   // in TON (e.g. "1.5")
+  seqno,    // wallet seqno fetched from the network
+  memoId,   // optional memo
+});
+// bocBase64 is the signed BOC ready for broadcast
+// txHash is the pre-computed transaction hash (needed for TON broadcast fallback)
+```
+
+## Design
+
+The split between signing and broadcasting allows the private key to stay on the client:
+
+```
+Backend                          Frontend (BerrySigner)         Backend
+  │                                      │                        │
+  │── prepare unsigned tx ──────────────>│                        │
+  │                                      │── sign with key        │
+  │<─────────────────────── signed tx ───│                        │
+  │                                                               │
+  │── broadcast to network ──────────────────────────────────────>│
+```
+
+## Private Key Format
+
+All functions accept the private key as a hex string (with or without `0x` prefix), except:
+- **Solana**: accepts hex or base58 encoded private key
+- **TRON**: accepts hex string
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@chainberry/berry-signer",
+  "version": "1.0.0",
+  "description": "Pure signing library for multiple blockchain networks — EVM, BTC, LTC, SOL, TRX, XRP, TON",
+  "keywords": ["blockchain", "signing", "wallet", "ethereum", "bitcoin", "solana", "tron", "ton", "xrp", "litecoin"],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "bitcoinjs-lib": ">=6.0.0",
+    "ecpair": ">=2.0.0",
+    "tiny-secp256k1": ">=2.0.0",
+    "ethers": ">=6.0.0",
+    "@solana/web3.js": ">=1.0.0",
+    "tronweb": ">=5.0.0",
+    "xrpl": ">=2.0.0",
+    "@ton/core": ">=0.50.0",
+    "@ton/crypto": ">=3.0.0",
+    "@ton/ton": ">=13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bitcoinjs-lib": { "optional": true },
+    "ecpair": { "optional": true },
+    "tiny-secp256k1": { "optional": true },
+    "ethers": { "optional": true },
+    "@solana/web3.js": { "optional": true },
+    "tronweb": { "optional": true },
+    "xrpl": { "optional": true },
+    "@ton/core": { "optional": true },
+    "@ton/crypto": { "optional": true },
+    "@ton/ton": { "optional": true }
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  }
+}

package/src/btc/btc-sign.ts

@@ -0,0 +1,22 @@
+import * as bitcoin from "bitcoinjs-lib";
+import ECPairFactory from "ecpair";
+import * as ecc from "tiny-secp256k1";
+import { parsePrivateKey } from "../utxo/parse-private-key";
+
+/**
+ * Pure signing — no network calls. `unsignedPsbtBase64` comes from
+ * wallet-broadcast's prepareBtcTransaction (a read-only call that fetches
+ * UTXOs/fee rate). Signs every input, finalizes, and returns the raw tx hex
+ * ready for broadcast.
+ */
+export function signBtcTransaction(privateKeyHex: string, unsignedPsbtBase64: string, isMainnet: boolean): string {
+  const network = isMainnet ? bitcoin.networks.bitcoin : bitcoin.networks.testnet;
+  const ECPair = ECPairFactory(ecc);
+  const keyPair = ECPair.fromPrivateKey(parsePrivateKey(privateKeyHex), { network });
+
+  const psbt = bitcoin.Psbt.fromBase64(unsignedPsbtBase64, { network });
+  for (let i = 0; i < psbt.inputCount; i++) psbt.signInput(i, keyPair);
+  psbt.finalizeAllInputs();
+
+  return psbt.extractTransaction().toHex();
+}

package/src/evm/evm-sign.ts

@@ -0,0 +1,43 @@
+import { ethers } from "ethers";
+
+export type EvmUnsignedTx = {
+  to: string;
+  chainId: number;
+  nonce: number;
+  gasLimit: string;
+  value?: string;
+  data?: string;
+  gasPrice?: string;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+};
+
+function formatPrivateKey(key: string): string {
+  return key.startsWith("0x") ? key : `0x${key}`;
+}
+
+/**
+ * Pure signing — no network calls, no key storage/decryption.
+ * Caller (frontend or backend) supplies the raw private key directly.
+ * `unsignedTx` must already carry nonce/gas/chainId, since those require
+ * a prior read-only RPC call (see wallet-broadcast's prepare helpers).
+ */
+export function signEvmTransaction(privateKeyHex: string, unsignedTx: EvmUnsignedTx): Promise<string> {
+  const wallet = new ethers.Wallet(formatPrivateKey(privateKeyHex));
+  const txRequest: ethers.TransactionRequest = {
+    to: unsignedTx.to,
+    chainId: unsignedTx.chainId,
+    nonce: unsignedTx.nonce,
+    gasLimit: BigInt(unsignedTx.gasLimit),
+    value: unsignedTx.value !== undefined ? BigInt(unsignedTx.value) : undefined,
+    data: unsignedTx.data,
+  };
+  if (unsignedTx.maxFeePerGas !== undefined) {
+    txRequest.maxFeePerGas = BigInt(unsignedTx.maxFeePerGas);
+    txRequest.maxPriorityFeePerGas =
+      unsignedTx.maxPriorityFeePerGas !== undefined ? BigInt(unsignedTx.maxPriorityFeePerGas) : undefined;
+  } else if (unsignedTx.gasPrice !== undefined) {
+    txRequest.gasPrice = BigInt(unsignedTx.gasPrice);
+  }
+  return wallet.signTransaction(txRequest);
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./evm/evm-sign";
+export * from "./xrp/xrp-sign";
+export * from "./sol/sol-sign";
+export * from "./trx/trx-sign";
+export * from "./btc/btc-sign";
+export * from "./ltc/ltc-sign";
+export * from "./ton/ton-sign";

package/src/ltc/ltc-sign.ts

@@ -0,0 +1,53 @@
+import * as bitcoin from "bitcoinjs-lib";
+import ECPairFactory from "ecpair";
+import * as ecc from "tiny-secp256k1";
+import { parsePrivateKey } from "../utxo/parse-private-key";
+
+const LITECOIN_MAINNET: bitcoin.Network = {
+  messagePrefix: "\x19Litecoin Signed Message:\n",
+  bech32: "ltc",
+  bip32: { public: 0x019da462, private: 0x019d9cfe },
+  pubKeyHash: 0x30,
+  scriptHash: 0x32,
+  wif: 0xb0,
+};
+const LITECOIN_TESTNET: bitcoin.Network = {
+  messagePrefix: "\x19Litecoin Signed Message:\n",
+  bech32: "tltc",
+  bip32: { public: 0x0436f6e1, private: 0x0436ef7d },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+
+/**
+ * Pure signing — no network calls. `unsignedPsbtBase64` comes from
+ * wallet-broadcast's prepareLtcTransaction (a read-only call that fetches
+ * UTXOs/fee rate). Signs every input, finalizes, and returns the raw tx hex
+ * ready for broadcast.
+ */
+export function signLtcTransaction(privateKeyHex: string, unsignedPsbtBase64: string, isMainnet: boolean): string {
+  const network = isMainnet ? LITECOIN_MAINNET : LITECOIN_TESTNET;
+  const ECPair = ECPairFactory(ecc);
+  const keyPair = ECPair.fromPrivateKey(parsePrivateKey(privateKeyHex), { network });
+
+  const psbt = bitcoin.Psbt.fromBase64(unsignedPsbtBase64, { network });
+  for (let i = 0; i < psbt.inputCount; i++) psbt.signInput(i, keyPair);
+  psbt.finalizeAllInputs();
+
+  return psbt.extractTransaction().toHex();
+}
+
+/**
+ * Derives the P2WPKH address for a raw private key. WalletCore (TrustWallet) has no
+ * native Litecoin testnet support, so this is the one place that still needs bitcoinjs-lib
+ * for address derivation — kept here instead of duplicated at call sites.
+ */
+export function getLtcAddressFromPrivateKey(privateKeyHex: string, isMainnet: boolean): string {
+  const network = isMainnet ? LITECOIN_MAINNET : LITECOIN_TESTNET;
+  const ECPair = ECPairFactory(ecc);
+  const keyPair = ECPair.fromPrivateKey(parsePrivateKey(privateKeyHex), { network });
+  const address = bitcoin.payments.p2wpkh({ pubkey: keyPair.publicKey, network }).address;
+  if (!address) throw new Error("Failed to derive LTC address");
+  return address;
+}

package/src/sol/sol-sign.ts

@@ -0,0 +1,31 @@
+import bs58 from "bs58";
+import { Keypair, Transaction } from "@solana/web3.js";
+
+function getSolKeypairFromPrivateKey(privateKey: string): Keypair {
+  const cleanedKey = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+  let secretKey: Uint8Array;
+  if (/^[0-9a-fA-F]+$/.test(cleanedKey)) {
+    secretKey = Uint8Array.from(Buffer.from(cleanedKey, "hex"));
+  } else {
+    try {
+      secretKey = bs58.decode(cleanedKey);
+    } catch (error) {
+      throw new Error(`Invalid private key encoding: not valid hex or base58 (${(error as Error).message})`);
+    }
+  }
+  if (secretKey.length === 64) return Keypair.fromSecretKey(secretKey);
+  if (secretKey.length === 32) return Keypair.fromSeed(secretKey);
+  throw new Error(`Invalid private key length: ${secretKey.length} bytes. Expected 32 or 64 bytes.`);
+}
+
+/**
+ * Pure signing — no network calls. `unsignedTxBase64` must already carry
+ * recentBlockhash/feePayer/instructions (see wallet-broadcast's
+ * prepareSolTransaction, a read-only RPC call).
+ */
+export function signSolTransaction(privateKey: string, unsignedTxBase64: string): string {
+  const keypair = getSolKeypairFromPrivateKey(privateKey);
+  const transaction = Transaction.from(Buffer.from(unsignedTxBase64, "base64"));
+  transaction.sign(keypair);
+  return transaction.serialize().toString("base64");
+}

package/src/ton/ton-sign.ts

@@ -0,0 +1,38 @@
+import { external, storeMessage } from "@ton/core";
+import { keyPairFromSeed } from "@ton/crypto";
+import { Address, beginCell, Cell, internal, toNano, WalletContractV4 } from "@ton/ton";
+
+function getKeyPairFromPrivateKey(privateKeyHex: string): { publicKey: Buffer; secretKey: Buffer } {
+  const raw = privateKeyHex.replace(/^0x/i, "");
+  if (raw.length !== 64) throw new Error(`Invalid TON private key length: ${raw.length} hex chars. Expected 64 (32 bytes).`);
+  return keyPairFromSeed(Buffer.from(raw, "hex"));
+}
+
+export type SignedTonTx = { bocBase64: string; txHash: string };
+
+/**
+ * Pure signing — no network calls. `seqno` comes from wallet-broadcast's
+ * fetchTonSeqno (a read-only RPC call).
+ */
+export function signTonTransaction(
+  privateKeyHex: string,
+  params: { toAddress: string; amount: string; seqno: number; memoId?: string }
+): SignedTonTx {
+  const keyPair = getKeyPairFromPrivateKey(privateKeyHex);
+  const wallet = WalletContractV4.create({ workchain: 0, publicKey: keyPair.publicKey });
+  const walletAddress = wallet.address;
+
+  const recipientAddress = Address.parse(params.toAddress.trim());
+  const amountInNano = toNano(params.amount);
+  let body: Cell | undefined;
+  if (params.memoId) {
+    body = beginCell().storeUint(0, 32).storeStringTail(params.memoId).endCell();
+  }
+
+  const internalMessage = internal({ to: recipientAddress, value: amountInNano, body, bounce: false });
+  const transferBody = wallet.createTransfer({ secretKey: keyPair.secretKey, messages: [internalMessage], seqno: params.seqno });
+  const extMessage = external({ to: walletAddress, init: params.seqno === 0 ? wallet.init : undefined, body: transferBody });
+  const bocBytes = beginCell().store(storeMessage(extMessage)).endCell().toBoc();
+
+  return { bocBase64: Buffer.from(bocBytes).toString("base64"), txHash: transferBody.hash().toString("hex") };
+}

package/src/trx/trx-sign.ts

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+let TronWeb = require("tronweb");
+if (TronWeb.TronWeb) TronWeb = TronWeb.TronWeb;
+else if (TronWeb.default) TronWeb = TronWeb.default;
+
+/**
+ * Pure signing — TronWeb's signing call itself makes no network request, but its
+ * constructor still requires node URLs (an SDK quirk, not an actual dependency for
+ * signing). `rpcUrl` can be any reachable TRON node; it is never called during sign.
+ * `unsignedTx` comes from wallet-broadcast's prepareTrxTransaction (a read-only call).
+ */
+export async function signTrxTransaction(privateKey: string, unsignedTx: unknown, rpcUrl: string): Promise<string> {
+  const cleanPrivateKey = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+  const tronWeb = new TronWeb({ fullNode: rpcUrl, solidityNode: rpcUrl, eventServer: rpcUrl, privateKey: cleanPrivateKey });
+  const signedTx = await tronWeb.trx.sign(unsignedTx, cleanPrivateKey);
+  return JSON.stringify(signedTx);
+}

package/src/utxo/parse-private-key.ts

@@ -0,0 +1,14 @@
+/**
+ * Decodes a raw UTXO-chain private key from either a 32-byte hex string or the
+ * legacy hex-of-UTF8-bytes-of-comma-separated-decimal format used by older wallets.
+ */
+export function parsePrivateKey(decryptedKey: string, coinLabel = "UTXO"): Buffer {
+  const raw = Buffer.from(decryptedKey.replace(/^0x/, ""), "hex");
+  if (raw.length === 32) return raw;
+  const asString = raw.toString("utf8");
+  const parts = asString.split(",").map(Number);
+  if (parts.length === 32 && parts.every((b) => Number.isInteger(b) && b >= 0 && b <= 255)) {
+    return Buffer.from(parts);
+  }
+  throw new Error(`Invalid ${coinLabel} private key: expected 32 bytes, got ${raw.length}`);
+}

package/src/xrp/xrp-sign.ts

@@ -0,0 +1,21 @@
+import * as ecc from "tiny-secp256k1";
+import { Payment, Wallet as XrplWallet } from "xrpl";
+
+function buildXrplWallet(privateKeyHex: string): XrplWallet {
+  const raw = privateKeyHex.replace(/^0x/i, "");
+  const pubKeyBuf = ecc.pointFromScalar(Buffer.from(raw, "hex"), true);
+  if (!pubKeyBuf) throw new Error("Failed to derive XRP public key from private key");
+  const pubKeyHex = Buffer.from(pubKeyBuf).toString("hex").toUpperCase();
+  const prefixedPriv = raw.startsWith("00") ? raw : `00${raw}`;
+  return new XrplWallet(pubKeyHex, prefixedPriv);
+}
+
+/**
+ * Pure signing — no network calls. `preparedTx` must already carry
+ * Sequence/Fee/LastLedgerSequence (xrpl's autofill, a read-only RPC call —
+ * see wallet-broadcast's prepareXrpTransaction).
+ */
+export function signXrpTransaction(privateKeyHex: string, preparedTx: Payment): string {
+  const wallet = buildXrplWallet(privateKeyHex);
+  return wallet.sign(preparedTx).tx_blob;
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declarationDir": "dist",
+    "module": "CommonJS",
+    "moduleResolution": "Node10"
+  },
+  "include": ["src"],
+  "references": []
+}

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "../../",
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "module": "CommonJS",
+    "moduleResolution": "Node10",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": []
+}