@swapkit/toolboxes 0.0.0-nightly-20250304130539

package/src/solana/index.ts

@@ -0,0 +1,49 @@
+import type { PublicKey, SendOptions, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { Chain } from "@swapkit/helpers";
+import type { SOLToolbox } from "./toolbox";
+
+type DisplayEncoding = "utf8" | "hex";
+
+type PhantomEvent = "connect" | "disconnect" | "accountChanged";
+
+type PhantomRequestMethod =
+  | "connect"
+  | "disconnect"
+  | "signAndSendTransaction"
+  | "signAndSendTransactionV0"
+  | "signAndSendTransactionV0WithLookupTable"
+  | "signTransaction"
+  | "signAllTransactions"
+  | "signMessage";
+
+interface ConnectOpts {
+  onlyIfTrusted: boolean;
+}
+
+export * from "./toolbox";
+
+export type SolanaWallets = {
+  [Chain.Solana]: ReturnType<typeof SOLToolbox>;
+};
+
+export interface SolanaProvider {
+  connect: (opts?: Partial<ConnectOpts>) => Promise<{ publicKey: PublicKey }>;
+  disconnect: () => Promise<void>;
+  getAddress: () => Promise<string>;
+  isConnected: boolean | null;
+  isPhantom: boolean;
+  on: (event: PhantomEvent, handler: (args: any) => void) => void;
+  publicKey: PublicKey | null;
+  request: (method: PhantomRequestMethod, params: any) => Promise<unknown>;
+  signMessage: (message: Uint8Array | string, display?: DisplayEncoding) => Promise<any>;
+  signAndSendTransaction: (
+    transaction: Transaction | VersionedTransaction,
+    opts?: SendOptions,
+  ) => Promise<{ signature: string; publicKey: PublicKey }>;
+  signTransaction: <T extends Transaction | VersionedTransaction = Transaction>(
+    transaction: T,
+  ) => Promise<T>;
+  signAllTransactions: <T extends Transaction | VersionedTransaction = Transaction>(
+    transactions: T[],
+  ) => Promise<T[]>;
+}

package/src/solana/toolbox.ts

@@ -0,0 +1,271 @@
+import type { Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js";
+import {
+  AssetValue,
+  Chain,
+  DerivationPath,
+  SKConfig,
+  SwapKitError,
+  SwapKitNumber,
+  type WalletTxParams,
+} from "@swapkit/helpers";
+
+export async function getAddressValidator() {
+  const { PublicKey } = await import("@solana/web3.js");
+
+  return (address: string) => {
+    try {
+      const pubkey = new PublicKey(address);
+      return PublicKey.isOnCurve(pubkey.toBytes());
+    } catch (_) {
+      return false;
+    }
+  };
+}
+
+export async function createSolanaTokenTransaction({
+  tokenAddress,
+  recipient,
+  from,
+  connection,
+  amount,
+  decimals,
+}: {
+  tokenAddress: string;
+  recipient: string;
+  from: PublicKey;
+  connection: Connection;
+  amount: number;
+  decimals: number;
+}) {
+  const {
+    getAssociatedTokenAddress,
+    getAccount,
+    createAssociatedTokenAccountInstruction,
+    createTransferCheckedInstruction,
+  } = await import("@solana/spl-token");
+  const { Transaction, PublicKey } = await import("@solana/web3.js");
+
+  const transaction = new Transaction();
+  const tokenPublicKey = new PublicKey(tokenAddress);
+  const fromSPLAddress = await getAssociatedTokenAddress(tokenPublicKey, from);
+
+  const recipientPublicKey = new PublicKey(recipient);
+  const recipientSPLAddress = await getAssociatedTokenAddress(tokenPublicKey, recipientPublicKey);
+
+  let recipientAccountExists = false;
+  try {
+    await getAccount(connection, recipientSPLAddress);
+    recipientAccountExists = true;
+  } catch (_) {
+    // Recipient's associated token account doesn't exist
+  }
+
+  if (!recipientAccountExists) {
+    transaction.add(
+      createAssociatedTokenAccountInstruction(
+        from,
+        recipientSPLAddress,
+        recipientPublicKey,
+        tokenPublicKey,
+      ),
+    );
+  }
+
+  transaction.add(
+    createTransferCheckedInstruction(
+      fromSPLAddress,
+      tokenPublicKey,
+      recipientSPLAddress,
+      from,
+      amount,
+      decimals,
+    ),
+  );
+
+  return transaction;
+}
+
+export const SOLToolbox = () => {
+  async function getConnection() {
+    const { Connection } = await import("@solana/web3.js");
+    return new Connection(SKConfig.get("rpcUrls").SOL, "confirmed");
+  }
+
+  return {
+    getConnection,
+    createKeysForPath,
+    getAddressFromKeys,
+    createSolanaTransaction: createSolanaTransaction(getConnection),
+    getBalance: getBalance(getConnection),
+    transfer: transfer(getConnection),
+    broadcastTransaction: broadcastTransaction(getConnection),
+    getAddressValidator,
+  };
+};
+
+function createSolanaTransaction(getConnection: () => Promise<Connection>) {
+  return async ({
+    recipient,
+    assetValue,
+    fromPublicKey,
+    memo,
+    isProgramDerivedAddress,
+  }: WalletTxParams & {
+    assetValue: AssetValue;
+    fromPublicKey: PublicKey;
+    isProgramDerivedAddress?: boolean;
+  }) => {
+    const { createMemoInstruction } = await import("@solana/spl-memo");
+    const { Transaction, PublicKey, SystemProgram } = await import("@solana/web3.js");
+    const validateAddress = await getAddressValidator();
+
+    if (!(isProgramDerivedAddress || validateAddress(recipient))) {
+      throw new SwapKitError("core_transaction_invalid_recipient_address");
+    }
+
+    const connection = await getConnection();
+
+    const transaction = assetValue.isGasAsset
+      ? new Transaction().add(
+          SystemProgram.transfer({
+            fromPubkey: fromPublicKey,
+            lamports: assetValue.getBaseValue("number"),
+            toPubkey: new PublicKey(recipient),
+          }),
+        )
+      : assetValue.address
+        ? await createSolanaTokenTransaction({
+            amount: assetValue.getBaseValue("number"),
+            connection,
+            decimals: assetValue.decimal as number,
+            from: fromPublicKey,
+            recipient,
+            tokenAddress: assetValue.address,
+          })
+        : undefined;
+
+    if (!transaction) {
+      throw new SwapKitError("core_transaction_invalid_sender_address");
+    }
+
+    if (memo) transaction.add(createMemoInstruction(memo));
+
+    const blockHash = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockHash.blockhash;
+    transaction.feePayer = fromPublicKey;
+
+    return transaction;
+  };
+}
+
+function transfer(getConnection: () => Promise<Connection>) {
+  return async ({
+    recipient,
+    assetValue,
+    fromKeypair,
+    memo,
+    isProgramDerivedAddress,
+  }: WalletTxParams & {
+    assetValue: AssetValue;
+    fromKeypair: Keypair;
+    isProgramDerivedAddress?: boolean;
+  }) => {
+    const { sendAndConfirmTransaction } = await import("@solana/web3.js");
+    const connection = await getConnection();
+
+    const transaction = await createSolanaTransaction(getConnection)({
+      recipient,
+      assetValue,
+      memo,
+      fromPublicKey: fromKeypair.publicKey,
+      isProgramDerivedAddress,
+    });
+
+    return sendAndConfirmTransaction(connection, transaction, [fromKeypair]);
+  };
+}
+
+function broadcastTransaction(getConnection: () => Promise<Connection>) {
+  return async (transaction: Transaction) => {
+    const connection = await getConnection();
+    return connection.sendRawTransaction(transaction.serialize());
+  };
+}
+
+async function createKeysForPath({
+  phrase,
+  derivationPath = DerivationPath.SOL,
+}: { phrase: string; derivationPath?: string }) {
+  const { HDKey } = await import("micro-key-producer/slip10.js");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+  const { Keypair } = await import("@solana/web3.js");
+  const seed = mnemonicToSeedSync(phrase);
+  const hdKey = HDKey.fromMasterSeed(seed);
+
+  return Keypair.fromSeed(hdKey.derive(derivationPath, true).privateKey);
+}
+
+function getAddressFromKeys(keypair: Keypair) {
+  return keypair.publicKey.toString();
+}
+
+async function getTokenBalances({
+  connection,
+  address,
+}: { connection: Connection; address: string }) {
+  const { PublicKey } = await import("@solana/web3.js");
+  const { TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
+  const { TokenListProvider } = await import("@solana/spl-token-registry");
+
+  const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(address), {
+    programId: TOKEN_PROGRAM_ID,
+  });
+  const tokenListProvider = new TokenListProvider();
+  const tokenListContainer = await tokenListProvider.resolve();
+  const tokenList = tokenListContainer.filterByChainId(101).getList();
+
+  // Group token balances by mint address
+  const tokenBalanceMap = new Map<string, { amount: bigint; decimal: number; symbol: string }>();
+
+  for await (const tokenAccountInfo of tokenAccounts.value) {
+    const accountInfo = tokenAccountInfo.account.data.parsed.info;
+    const mintAddress = accountInfo.mint;
+    const decimal = accountInfo.tokenAmount.decimals;
+    const amount = BigInt(accountInfo.tokenAmount.amount);
+
+    if (amount <= BigInt(0)) continue;
+
+    const tokenInfo = tokenList.find((token) => token.address === mintAddress);
+    const tokenSymbol = tokenInfo?.symbol ?? "UNKNOWN";
+    const existing = tokenBalanceMap.get(mintAddress);
+
+    tokenBalanceMap.set(mintAddress, {
+      amount: existing ? existing.amount + amount : amount,
+      decimal,
+      symbol: tokenSymbol,
+    });
+  }
+
+  // Convert grouped balances to AssetValue array
+  const tokenBalances: AssetValue[] = Array.from(tokenBalanceMap.entries()).map(
+    ([mintAddress, { amount, decimal, symbol }]) =>
+      new AssetValue({
+        value: SwapKitNumber.fromBigInt(amount, decimal),
+        decimal,
+        identifier: `${Chain.Solana}.${symbol}${mintAddress ? `-${mintAddress.toString()}` : ""}`,
+      }),
+  );
+
+  return tokenBalances;
+}
+
+function getBalance(getConnection: () => Promise<Connection>) {
+  return async (address: string) => {
+    const { PublicKey } = await import("@solana/web3.js");
+    const connection = await getConnection();
+    const SOLBalance = await connection.getBalance(new PublicKey(address));
+    const tokenBalances = await getTokenBalances({ connection, address });
+
+    return [AssetValue.from({ chain: Chain.Solana, value: BigInt(SOLBalance) }), ...tokenBalances];
+  };
+}

package/src/substrate/index.ts

@@ -0,0 +1,3 @@
+export * from "./toolbox/baseSubstrateToolbox";
+export * from "./toolbox";
+export * from "./types/index";

package/src/substrate/toolbox/baseSubstrateToolbox.ts

@@ -0,0 +1,288 @@
+import type { ApiPromise } from "@polkadot/api";
+import type { SubmittableExtrinsic } from "@polkadot/api/types";
+import type { KeyringPair } from "@polkadot/keyring/types";
+import type { Callback, IKeyringPair, ISubmittableResult, Signer } from "@polkadot/types/types";
+import { hexToU8a, isHex, u8aToHex } from "@polkadot/util";
+import {
+  decodeAddress as decodePolkadotAddress,
+  encodeAddress as encodePolkadotAddress,
+} from "@polkadot/util-crypto";
+import {
+  AssetValue,
+  Chain,
+  SKConfig,
+  type SubstrateChain,
+  SwapKitError,
+  SwapKitNumber,
+} from "@swapkit/helpers";
+
+import { Network, type SubstrateNetwork } from "../types/network";
+
+// TODO combine this type with the more general SK type
+type SubstrateTransferParams = {
+  recipient: string;
+  assetValue: AssetValue;
+  from?: string;
+};
+
+export const isKeyringPair = (account: IKeyringPair | Signer): account is IKeyringPair => {
+  return "address" in account;
+};
+
+export const createKeyring = async (phrase: string, networkPrefix: number) => {
+  const { Keyring } = await import("@polkadot/api");
+  const { cryptoWaitReady } = await import("@polkadot/util-crypto");
+  await cryptoWaitReady();
+
+  return new Keyring({ type: "sr25519", ss58Format: networkPrefix }).addFromUri(phrase);
+};
+
+const getNonce = (api: ApiPromise, address: string) => api.rpc.system.accountNextIndex(address);
+
+const getBalance = async (api: ApiPromise, gasAsset: AssetValue, address: string) => {
+  const data = await api.query.system?.account?.(address);
+
+  // @ts-expect-error @Towan some parts of data missing?
+  if (!data?.data?.free || data?.data?.isEmpty) {
+    return [gasAsset.set(0)];
+  }
+
+  return [
+    gasAsset.set(
+      // @ts-expect-error @Towan some parts of data missing?
+      SwapKitNumber.fromBigInt(BigInt(data.data.free.toString()), gasAsset.decimal).getValue(
+        "string",
+      ),
+    ),
+  ];
+};
+
+const validateAddress = (address: string, networkPrefix: number) => {
+  try {
+    const decodedAddress = decodeAddress(address, networkPrefix);
+
+    encodeAddress(decodedAddress, "ss58", networkPrefix);
+
+    return true;
+  } catch (_error) {
+    return false;
+  }
+};
+
+const createTransfer = (
+  api: ApiPromise,
+  { recipient, amount }: { recipient: string; amount: number },
+) => api.tx.balances?.transferAllowDeath?.(recipient, amount);
+
+const transfer = async (
+  api: ApiPromise,
+  signer: IKeyringPair | Signer,
+  { recipient, assetValue, from }: SubstrateTransferParams,
+) => {
+  const transfer = createTransfer(api, {
+    recipient,
+    amount: assetValue.getBaseValue("number"),
+  });
+
+  const isKeyring = isKeyringPair(signer);
+
+  if (!transfer) return;
+
+  const address = from || (isKeyring ? (signer as IKeyringPair).address : undefined);
+  if (!address) throw new SwapKitError("core_transaction_invalid_sender_address");
+
+  const nonce = await getNonce(api, address);
+
+  const tx = await transfer.signAndSend(isKeyring ? signer : address, {
+    signer: isKeyring ? undefined : signer,
+    nonce,
+  });
+
+  return tx?.toString();
+};
+
+const estimateTransactionFee = async (
+  api: ApiPromise,
+  signer: IKeyringPair | Signer,
+  gasAsset: AssetValue,
+  { recipient, assetValue, from }: SubstrateTransferParams,
+) => {
+  const transfer = createTransfer(api, { recipient, amount: assetValue.getBaseValue("number") });
+
+  const address = from || (isKeyringPair(signer) && signer.address);
+  if (!address) return;
+
+  const paymentInfo = (await transfer?.paymentInfo(address, {
+    nonce: await getNonce(api, address),
+  })) || { partialFee: 0 };
+  return gasAsset.set(
+    SwapKitNumber.fromBigInt(BigInt(paymentInfo.partialFee.toString()), gasAsset.decimal).getValue(
+      "string",
+    ),
+  );
+};
+
+const broadcast = async (
+  tx: SubmittableExtrinsic<"promise">,
+  callback?: Callback<ISubmittableResult>,
+) => {
+  if (callback) return tx.send(callback);
+  const hash = await tx.send();
+  return hash.toString();
+};
+
+const sign = async (signer: IKeyringPair, tx: SubmittableExtrinsic<"promise">) => {
+  const signedTx = await tx.signAsync(signer);
+  return signedTx;
+};
+
+const signAndBroadcastKeyring = (
+  signer: IKeyringPair,
+  tx: SubmittableExtrinsic<"promise">,
+  callback?: Callback<ISubmittableResult>,
+) => {
+  if (callback) return tx.signAndSend(signer, callback);
+  const hash = tx.signAndSend(signer);
+  return hash.toString();
+};
+
+const signAndBroadcast = async ({
+  signer,
+  address,
+  tx,
+  callback,
+  api,
+}: {
+  signer: Signer;
+  address: string;
+  tx: SubmittableExtrinsic<"promise">;
+  api: ApiPromise;
+  callback?: Callback<ISubmittableResult>;
+}) => {
+  const nonce = await getNonce(api, address);
+  if (callback) {
+    tx.signAndSend(address, { nonce, signer }, callback);
+  }
+  const hash = tx.signAndSend(address, { nonce, signer });
+  return hash.toString();
+};
+
+function convertAddress(address: string, newPrefix: number) {
+  const decodedAddress = decodePolkadotAddress(address);
+  const convertedAddress = encodePolkadotAddress(decodedAddress, newPrefix);
+  return convertedAddress;
+}
+
+function decodeAddress(address: string, networkPrefix?: number) {
+  return isHex(address)
+    ? hexToU8a(address)
+    : decodePolkadotAddress(address, undefined, networkPrefix);
+}
+
+function encodeAddress(
+  address: Uint8Array,
+  encoding: "ss58" | "hex" = "ss58",
+  networkPrefix?: number,
+) {
+  if (encoding === "hex") {
+    return u8aToHex(address);
+  }
+
+  return encodePolkadotAddress(address, networkPrefix);
+}
+
+export const BaseSubstrateToolbox = ({
+  api,
+  network,
+  gasAsset,
+  signer,
+}: {
+  api: ApiPromise;
+  network: SubstrateNetwork;
+  gasAsset: AssetValue;
+  signer: IKeyringPair | Signer;
+}) => ({
+  api,
+  network,
+  gasAsset,
+  decodeAddress,
+  encodeAddress,
+  convertAddress,
+  createKeyring: (phrase: string) => createKeyring(phrase, network.prefix),
+  getAddress: (keyring: IKeyringPair | Signer = signer) =>
+    isKeyringPair(keyring) ? keyring.address : undefined,
+  createTransfer: ({ recipient, assetValue }: { recipient: string; assetValue: AssetValue }) =>
+    createTransfer(api, { recipient, amount: assetValue.getBaseValue("number") }),
+  getBalance: (address: string) => getBalance(api, gasAsset, address),
+  validateAddress: (address: string) => validateAddress(address, network.prefix),
+  transfer: (params: SubstrateTransferParams) => transfer(api, signer, params),
+  estimateTransactionFee: (params: SubstrateTransferParams) =>
+    estimateTransactionFee(api, signer, gasAsset, params),
+  sign: (tx: SubmittableExtrinsic<"promise">) => {
+    if (isKeyringPair(signer)) {
+      return sign(signer, tx);
+    }
+    throw new SwapKitError(
+      "core_wallet_not_keypair_wallet",
+      "Signer does not have keyring pair capabilities required for signing.",
+    );
+  },
+  broadcast: (tx: SubmittableExtrinsic<"promise">, callback?: Callback<ISubmittableResult>) =>
+    broadcast(tx, callback),
+  signAndBroadcast: ({
+    tx,
+    callback,
+    address,
+  }: {
+    tx: SubmittableExtrinsic<"promise">;
+    callback?: Callback<ISubmittableResult>;
+    address?: string;
+  }) => {
+    if (isKeyringPair(signer)) {
+      return signAndBroadcastKeyring(signer, tx, callback);
+    }
+
+    if (address) {
+      return signAndBroadcast({ signer, address, tx, callback, api });
+    }
+
+    throw new SwapKitError(
+      "core_wallet_not_keypair_wallet",
+      "Signer does not have keyring pair capabilities required for signing.",
+    );
+  },
+});
+
+export const substrateValidateAddress = ({
+  address,
+  chain,
+}: { address: string; chain: Chain.Polkadot | Chain.Chainflip }) => {
+  const { prefix } = chain === Chain.Polkadot ? Network.DOT : Network.FLIP;
+
+  return validateAddress(address, prefix) || validateAddress(address, Network.GENERIC.prefix);
+};
+
+export async function ToolboxFactory({
+  generic,
+  chain,
+  signer,
+}: ToolboxParams & { chain: SubstrateChain }) {
+  const { ApiPromise, WsProvider } = await import("@polkadot/api");
+
+  const provider = new WsProvider(SKConfig.get("rpcUrls")[chain]);
+  const api = await ApiPromise.create({ provider });
+  const gasAsset = AssetValue.from({ chain });
+  const network = generic ? Network.GENERIC : Network[chain];
+
+  return BaseSubstrateToolbox({ api, signer, gasAsset, network });
+}
+
+export type ToolboxParams = {
+  generic?: boolean;
+  signer: KeyringPair | Signer;
+};
+
+export type BaseSubstrateWallet = ReturnType<typeof BaseSubstrateToolbox>;
+export type SubstrateWallets = {
+  [chain in SubstrateChain]: BaseSubstrateWallet;
+};

package/src/substrate/toolbox/index.ts

@@ -0,0 +1,40 @@
+import { AssetValue, Chain } from "@swapkit/helpers";
+
+import { ToolboxFactory, type ToolboxParams } from "./baseSubstrateToolbox";
+
+export const PolkadotToolbox = ({ signer, generic = false }: ToolboxParams) => {
+  return ToolboxFactory({ chain: Chain.Polkadot, generic, signer });
+};
+
+export const ChainflipToolbox = async ({ signer, generic = false }: ToolboxParams) => {
+  const toolbox = await ToolboxFactory({ chain: Chain.Chainflip, generic, signer });
+
+  async function getBalance(address: string) {
+    // @ts-expect-error @Towan some parts of data missing?
+    // biome-ignore lint/correctness/noUnsafeOptionalChaining: @Towan some parts of data missing?
+    const { balance } = await toolbox.api.query.flip?.account?.(address);
+
+    return [AssetValue.from({ chain: Chain.Chainflip, value: BigInt(balance.toString()) })];
+  }
+
+  return { ...toolbox, getBalance };
+};
+
+type ToolboxType = {
+  DOT: ReturnType<typeof PolkadotToolbox>;
+  FLIP: ReturnType<typeof ChainflipToolbox>;
+};
+
+export const getToolboxByChain = <T extends keyof ToolboxType>(
+  chain: T,
+  params: ToolboxParams,
+): ToolboxType[T] => {
+  switch (chain) {
+    case Chain.Chainflip:
+      return ChainflipToolbox(params);
+    case Chain.Polkadot:
+      return PolkadotToolbox(params);
+    default:
+      throw new Error(`Chain ${chain} is not supported`);
+  }
+};

package/src/substrate/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./network";
+export * from "./wallet";

package/src/substrate/types/network.ts

@@ -0,0 +1,42 @@
+import type { SubstrateChain } from "@swapkit/helpers";
+
+export const polkadotNetwork = {
+  prefix: 0,
+  network: "polkadot",
+  displayName: "Polkadot Relay Chain",
+  symbols: ["DOT"],
+  decimals: [10],
+  standardAccount: "*25519",
+  website: "https://polkadot.network",
+};
+
+export const chainflipNetwork = {
+  prefix: 2112,
+  network: "chainflip",
+  displayName: "Chainflip",
+  symbols: ["FLIP"],
+  decimals: [18],
+  standardAccount: "*25519",
+  website: "https://chainflip.io/",
+};
+
+export const subtrateNetwork = {
+  prefix: 42,
+  network: "substrate",
+  displayName: "Substrate",
+  symbols: [],
+  decimals: [],
+  standardAccount: "*25519",
+  website: "https://substrate.io/",
+};
+
+export const Network: Record<SubstrateChain | "GENERIC", SubstrateNetwork> = {
+  DOT: polkadotNetwork,
+  FLIP: chainflipNetwork,
+  GENERIC: subtrateNetwork,
+};
+
+export type SubstrateNetwork =
+  | typeof polkadotNetwork
+  | typeof chainflipNetwork
+  | typeof subtrateNetwork;