@agentix/wallet-solana/dist/index.js

var __typeError = (msg) => {
  throw TypeError(msg);
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);

// src/SolanaWalletClient.ts
import { SolanaWalletBase } from "agentix";
import {
  PublicKey
} from "@solana/web3.js";
import { formatUnits } from "viem";
var SolanaWalletClient = class extends SolanaWalletBase {
  constructor(params) {
    super();
    this.connection = params.connection;
  }
  getChain() {
    return {
      type: "solana"
    };
  }
  getConnection() {
    return this.connection;
  }
  async balanceOf(address) {
    const pubkey = new PublicKey(address);
    const balance = await this.connection.getBalance(pubkey);
    return {
      decimals: 9,
      symbol: "SOL",
      name: "Solana",
      value: formatUnits(BigInt(balance), 9),
      inBaseUnits: balance.toString()
    };
  }
};

// src/SolanaKeypairWalletClient.ts
import {
  VersionedTransaction as VersionedTransaction2
} from "@solana/web3.js";
import nacl from "tweetnacl";
var isVersionedTransaction = (tx) => {
  return "version" in tx;
};
var _keypair;
var SolanaKeypairWalletClient = class extends SolanaWalletClient {
  constructor(params) {
    const { keypair, connection } = params;
    super({ connection });
    __privateAdd(this, _keypair);
    __privateSet(this, _keypair, keypair);
  }
  getAddress() {
    return __privateGet(this, _keypair).publicKey.toBase58();
  }
  async signTransaction(transaction) {
    if (isVersionedTransaction(transaction)) {
      transaction.sign([__privateGet(this, _keypair)]);
    } else {
      transaction.partialSign(__privateGet(this, _keypair));
    }
    return transaction;
  }
  async signAllTransactions(txs) {
    return txs.map((t) => {
      if (isVersionedTransaction(t)) {
        t.sign([__privateGet(this, _keypair)]);
      } else {
        t.partialSign(__privateGet(this, _keypair));
      }
      return t;
    });
  }
  async sendTransaction(transaction) {
    const connection = this.connection;
    if (transaction instanceof VersionedTransaction2) {
      transaction.sign([__privateGet(this, _keypair)]);
    } else {
      transaction.partialSign(__privateGet(this, _keypair));
    }
    return await connection.sendRawTransaction(transaction.serialize());
  }
  async signMessage(message) {
    const messageBytes = Buffer.from(message);
    const signature = nacl.sign.detached(messageBytes, __privateGet(this, _keypair).secretKey);
    return {
      signature: Buffer.from(signature).toString("hex")
    };
  }
  async signAndSendTransaction(transaction, options) {
    const connection = this.connection;
    if (transaction instanceof VersionedTransaction2) {
      transaction.sign([__privateGet(this, _keypair)]);
    } else {
      transaction.partialSign(__privateGet(this, _keypair));
    }
    const signature = await connection.sendRawTransaction(
      transaction.serialize(),
      options
    );
    return { signature };
  }
};
_keypair = new WeakMap();
var solanaKeypair = (params) => new SolanaKeypairWalletClient(params);

// src/SolanaAdaptorWalletClient.ts
var _publicKey, _sendTransaction, _signAllTransactions, _signMessage, _signTransaction;
var SolanaAdaptorWalletClient = class extends SolanaWalletClient {
  constructor(params) {
    const { publicKey, sendTransaction, signAllTransactions, signMessage, signTransaction, connection } = params;
    super({ connection });
    __privateAdd(this, _publicKey);
    __privateAdd(this, _sendTransaction);
    __privateAdd(this, _signAllTransactions);
    __privateAdd(this, _signMessage);
    __privateAdd(this, _signTransaction);
    __privateSet(this, _publicKey, publicKey);
    __privateSet(this, _sendTransaction, sendTransaction);
    __privateSet(this, _signAllTransactions, signAllTransactions);
    __privateSet(this, _signMessage, signMessage);
    __privateSet(this, _signTransaction, signTransaction);
  }
  getAddress() {
    return __privateGet(this, _publicKey).toBase58();
  }
  async signTransaction(transaction) {
    return __privateGet(this, _signTransaction).call(this, transaction);
  }
  async signAllTransactions(txs) {
    return __privateGet(this, _signAllTransactions).call(this, txs);
  }
  async sendTransaction(transaction) {
    return __privateGet(this, _sendTransaction).call(this, transaction, this.connection);
  }
  async signMessage(message) {
    const messageBytes = Buffer.from(message);
    const signature = await __privateGet(this, _signMessage).call(this, messageBytes);
    return {
      signature: Buffer.from(signature).toString("hex")
    };
  }
  async signAndSendTransaction(transaction, options) {
    const signature = await __privateGet(this, _sendTransaction).call(this, await __privateGet(this, _signTransaction).call(this, transaction), this.connection, options);
    return { signature };
  }
};
_publicKey = new WeakMap();
_sendTransaction = new WeakMap();
_signAllTransactions = new WeakMap();
_signMessage = new WeakMap();
_signTransaction = new WeakMap();
var solanaAdaptor = (params) => new SolanaAdaptorWalletClient(params);
export {
  SolanaAdaptorWalletClient,
  SolanaKeypairWalletClient,
  SolanaWalletClient,
  isVersionedTransaction,
  solanaAdaptor,
  solanaKeypair
};