@sodax/wallet-sdk-core 0.0.1-rc.1

package/dist/index.mjs

@@ -0,0 +1,680 @@
+import { privateKeyToAccount } from 'viem/accounts';
+import { createWalletClient, http, createPublicClient } from 'viem';
+import { nibiru, polygon, bsc, optimism, base, arbitrum, avalanche, sonic } from 'viem/chains';
+import { NIBIRU_MAINNET_CHAIN_ID, POLYGON_MAINNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, OPTIMISM_MAINNET_CHAIN_ID, BASE_MAINNET_CHAIN_ID, ARBITRUM_MAINNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, SONIC_MAINNET_CHAIN_ID, InjectiveExecuteResponse } from '@sodax/types';
+import { SuiClient } from '@mysten/sui/client';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { signTransaction } from '@mysten/wallet-standard';
+import * as IconSdkRaw from 'icon-sdk-js';
+import { MsgExecuteContract, createTransaction, MsgExecuteContractCompat } from '@injectivelabs/sdk-ts';
+import { getAssociatedTokenAddress } from '@solana/spl-token';
+import { Keypair, Connection, TransactionMessage, VersionedTransaction, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { Networks, Keypair as Keypair$1, Horizon, Transaction } from '@stellar/stellar-sdk';
+
+// src/wallet-providers/EvmWalletProvider.ts
+function getEvmViemChain(id) {
+  switch (id) {
+    case SONIC_MAINNET_CHAIN_ID:
+      return sonic;
+    case AVALANCHE_MAINNET_CHAIN_ID:
+      return avalanche;
+    case ARBITRUM_MAINNET_CHAIN_ID:
+      return arbitrum;
+    case BASE_MAINNET_CHAIN_ID:
+      return base;
+    case OPTIMISM_MAINNET_CHAIN_ID:
+      return optimism;
+    case BSC_MAINNET_CHAIN_ID:
+      return bsc;
+    case POLYGON_MAINNET_CHAIN_ID:
+      return polygon;
+    case NIBIRU_MAINNET_CHAIN_ID:
+      return nibiru;
+    default:
+      throw new Error(`Unsupported EVM chain ID: ${id}`);
+  }
+}
+var EvmWalletProvider = class {
+  walletClient;
+  publicClient;
+  constructor(config) {
+    if (isPrivateKeyEvmWalletConfig(config)) {
+      const chain = getEvmViemChain(config.chainId);
+      this.walletClient = createWalletClient({
+        chain,
+        transport: http(config.rpcUrl ?? chain.rpcUrls.default.http[0]),
+        account: privateKeyToAccount(config.privateKey)
+      });
+      this.publicClient = createPublicClient({
+        chain,
+        transport: http(config.rpcUrl ?? chain.rpcUrls.default.http[0])
+      });
+    } else if (isBrowserExtensionEvmWalletConfig(config)) {
+      this.walletClient = config.walletClient;
+      this.publicClient = config.publicClient;
+    } else {
+      throw new Error("Invalid EVM wallet config");
+    }
+  }
+  async sendTransaction(evmRawTx) {
+    return this.walletClient.sendTransaction(evmRawTx);
+  }
+  async waitForTransactionReceipt(txHash) {
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    return {
+      ...receipt,
+      transactionIndex: receipt.transactionIndex.toString(),
+      blockNumber: receipt.blockNumber.toString(),
+      cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+      gasUsed: receipt.gasUsed.toString(),
+      contractAddress: receipt.contractAddress?.toString() ?? null,
+      logs: receipt.logs.map((log) => ({
+        ...log,
+        blockNumber: log.blockNumber.toString(),
+        logIndex: log.logIndex.toString(),
+        transactionIndex: log.transactionIndex.toString()
+      })),
+      effectiveGasPrice: receipt.effectiveGasPrice.toString()
+    };
+  }
+  async getWalletAddress() {
+    return this.walletClient.account.address;
+  }
+};
+function isPrivateKeyEvmWalletConfig(config) {
+  return "privateKey" in config && config.privateKey.startsWith("0x");
+}
+function isBrowserExtensionEvmWalletConfig(config) {
+  return "walletClient" in config && "publicClient" in config;
+}
+function isPrivateKeySuiWalletConfig(walletConfig) {
+  return "mnemonics" in walletConfig;
+}
+function isBrowserExtensionSuiWalletConfig(walletConfig) {
+  return "wallet" in walletConfig && "account" in walletConfig;
+}
+function isPkSuiWallet(wallet) {
+  return "keyPair" in wallet;
+}
+function isBrowserExtensionSuiWallet(wallet) {
+  return "wallet" in wallet && "account" in wallet;
+}
+function isSuiWallet(wallet) {
+  return isPkSuiWallet(wallet) || isBrowserExtensionSuiWallet(wallet);
+}
+var SuiWalletProvider = class {
+  client;
+  wallet;
+  constructor(walletConfig) {
+    if (isPrivateKeySuiWalletConfig(walletConfig)) {
+      this.client = new SuiClient({ url: walletConfig.rpcUrl });
+      this.wallet = {
+        keyPair: Ed25519Keypair.deriveKeypair(walletConfig.mnemonics)
+      };
+    } else if (isBrowserExtensionSuiWalletConfig(walletConfig)) {
+      this.client = walletConfig.client;
+      this.wallet = {
+        wallet: walletConfig.wallet,
+        account: walletConfig.account
+      };
+    } else {
+      throw new Error("Invalid wallet configuration");
+    }
+  }
+  async signAndExecuteTxn(txn) {
+    if (isPkSuiWallet(this.wallet)) {
+      const res = await this.client.signAndExecuteTransaction({
+        transaction: txn,
+        signer: this.wallet.keyPair
+      });
+      return res.digest;
+    }
+    if (isBrowserExtensionSuiWallet(this.wallet)) {
+      const browserWallet = this.wallet.wallet;
+      const browserAccount = this.wallet.account;
+      if (!browserAccount || browserAccount.chains.length === 0) {
+        throw new Error("No chains available for wallet account");
+      }
+      const chain = browserAccount.chains[0];
+      if (!chain) {
+        throw new Error("No chain available for wallet account");
+      }
+      const { bytes, signature } = await signTransaction(browserWallet, {
+        transaction: txn,
+        account: browserAccount,
+        chain
+      });
+      const res = await this.client.executeTransactionBlock({
+        transactionBlock: bytes,
+        signature,
+        options: {
+          showRawEffects: true
+        }
+      });
+      return res.digest;
+    }
+    throw new Error("Invalid wallet configuration");
+  }
+  async viewContract(tx, packageId, module, functionName, args, typeArgs = []) {
+    tx.moveCall({
+      target: `${packageId}::${module}::${functionName}`,
+      arguments: args,
+      typeArguments: typeArgs
+    });
+    const sender = this.getSuiAddress();
+    const txResults = await this.client.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender
+    });
+    if (txResults.results && txResults.results[0] !== void 0) {
+      return txResults.results[0];
+    }
+    throw Error(`transaction didn't return any values: ${JSON.stringify(txResults, null, 2)}`);
+  }
+  async getCoins(address, token) {
+    return this.client.getCoins({ owner: address, coinType: token, limit: 10 });
+  }
+  getSuiAddress() {
+    if (isPkSuiWallet(this.wallet)) {
+      return this.wallet.keyPair.toSuiAddress();
+    }
+    if (isBrowserExtensionSuiWallet(this.wallet)) {
+      return this.wallet.account.address;
+    }
+    throw new Error("Invalid wallet configuration");
+  }
+  async getWalletAddress() {
+    return this.getSuiAddress();
+  }
+};
+var IconSdk = "default" in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw;
+var { Converter, CallTransactionBuilder, Wallet } = IconSdk;
+var IconWalletProvider = class {
+  wallet;
+  iconService;
+  constructor(wallet) {
+    if (isPrivateKeyIconWalletConfig(wallet)) {
+      this.wallet = {
+        type: "PRIVATE_KEY",
+        wallet: Wallet.loadPrivateKey(wallet.privateKey.slice(2))
+      };
+      this.iconService = new IconSdk.IconService(new IconSdk.IconService.HttpProvider(wallet.rpcUrl));
+    } else if (isBrowserExtensionIconWalletConfig(wallet)) {
+      this.wallet = {
+        type: "BROWSER_EXTENSION",
+        wallet: wallet.walletAddress
+      };
+      this.iconService = new IconSdk.IconService(new IconSdk.IconService.HttpProvider(wallet.rpcUrl));
+    } else {
+      throw new Error("Invalid Icon wallet config");
+    }
+  }
+  async sendTransaction(tx) {
+    const builtTx = new CallTransactionBuilder().from(tx.from).to(tx.to).stepLimit(Converter.toHex(2e6)).nid(tx.nid).version(tx.version ?? "0x3").timestamp(Converter.toHex(tx.timestamp ?? (/* @__PURE__ */ new Date()).getTime() * 1e3)).value(tx.value).method(tx.method).params(tx.params).build();
+    if (!isIconPkWallet(this.wallet)) {
+      const result2 = await requestJsonRpc(builtTx);
+      return result2.result;
+    }
+    const signedTx = new IconSdk.IconService.SignedTransaction(builtTx, this.wallet.wallet);
+    const result = await this.iconService.sendTransaction(signedTx).execute();
+    return result;
+  }
+  async waitForTransactionReceipt(txHash) {
+    const result = await this.iconService.waitTransactionResult(txHash).execute();
+    return {
+      ...result,
+      status: +result.status,
+      cumulativeStepUsed: BigNumberToBigInt(result.cumulativeStepUsed),
+      stepUsed: BigNumberToBigInt(result.stepUsed),
+      stepPrice: BigNumberToBigInt(result.stepPrice)
+    };
+  }
+  async getWalletAddress() {
+    if (!this.wallet.wallet) {
+      throw new Error("Wallet not initialized");
+    }
+    return isIconPkWallet(this.wallet) ? this.wallet.wallet.getAddress() : this.wallet.wallet;
+  }
+};
+function isIconPkWallet(wallet) {
+  return wallet.type === "PRIVATE_KEY";
+}
+function isIconBrowserExtensionWallet(wallet) {
+  return wallet.type === "BROWSER_EXTENSION";
+}
+function isPrivateKeyIconWalletConfig(config) {
+  return "privateKey" in config && config.privateKey.startsWith("0x");
+}
+function isBrowserExtensionIconWalletConfig(config) {
+  return "walletAddress" in config && (isIconEoaAddress(config.walletAddress) || !config.walletAddress);
+}
+function isIconAddress(value) {
+  return typeof value === "string" && /^hx[a-f0-9]{40}$|^cx[a-f0-9]{40}$/.test(value);
+}
+function isIconEoaAddress(value) {
+  return typeof value === "string" && /^hx[a-f0-9]{40}$/.test(value);
+}
+function isResponseAddressType(value) {
+  return typeof value === "object" && value !== null && "type" in value && "payload" in value && value.type === "RESPONSE_ADDRESS" && isIconAddress(value.payload);
+}
+function isResponseSigningType(value) {
+  return typeof value === "object" && value !== null && "type" in value && "payload" in value && value.type === "RESPONSE_SIGNING" && typeof value.payload === "string";
+}
+function isJsonRpcPayloadResponse(value) {
+  return typeof value === "object" && value !== null && "id" in value && "result" in value && typeof value.result === "string";
+}
+function requestAddress() {
+  return new Promise((resolve) => {
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const response = customEvent.detail;
+      if (isResponseAddressType(response)) {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        resolve(response.payload);
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(
+      new CustomEvent("ICONEX_RELAY_REQUEST", {
+        detail: {
+          type: "REQUEST_ADDRESS"
+        }
+      })
+    );
+  });
+}
+function requestSigning(from, hash) {
+  return new Promise((resolve, reject) => {
+    const signRequest = new CustomEvent("ICONEX_RELAY_REQUEST", {
+      detail: {
+        type: "REQUEST_SIGNING",
+        payload: {
+          from,
+          hash
+        }
+      }
+    });
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const response = customEvent.detail;
+      if (isResponseSigningType(response)) {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        resolve(response.payload);
+      } else if (response.type === "CANCEL_SIGNING") {
+        reject(new Error("CANCEL_SIGNING"));
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(signRequest);
+  });
+}
+function requestJsonRpc(rawTransaction, id = 99999) {
+  return new Promise((resolve, reject) => {
+    const eventHandler = (event) => {
+      const customEvent = event;
+      const { type, payload } = customEvent.detail;
+      if (type === "RESPONSE_JSON-RPC") {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        if (isJsonRpcPayloadResponse(payload)) {
+          resolve(payload);
+        } else {
+          reject(new Error("Invalid payload response type (expected JsonRpcPayloadResponse)"));
+        }
+      } else if (type === "CANCEL_JSON-RPC") {
+        window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+        reject(new Error("CANCEL_JSON-RPC"));
+      }
+    };
+    window.removeEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.addEventListener("ICONEX_RELAY_RESPONSE", eventHandler, false);
+    window.dispatchEvent(
+      new CustomEvent("ICONEX_RELAY_REQUEST", {
+        detail: {
+          type: "REQUEST_JSON-RPC",
+          payload: {
+            jsonrpc: "2.0",
+            method: "icx_sendTransaction",
+            params: rawTransaction,
+            id
+          }
+        }
+      })
+    );
+  });
+}
+function BigNumberToBigInt(bigNumber) {
+  if (!bigNumber.isInteger()) {
+    throw new Error("Cannot convert decimal number to BigInt");
+  }
+  return BigInt(bigNumber.toFixed(0));
+}
+function isBrowserExtensionInjectiveWalletConfig(config) {
+  return "msgBroadcaster" in config && "walletAddress" in config;
+}
+var InjectiveWalletProvider = class {
+  msgBroadcaster;
+  walletAddress;
+  constructor(config) {
+    if (isBrowserExtensionInjectiveWalletConfig(config)) {
+      this.msgBroadcaster = config.msgBroadcaster;
+      this.walletAddress = config.walletAddress;
+    } else {
+      throw new Error("Invalid Injective wallet config");
+    }
+  }
+  getRawTransaction(chainId, _, senderAddress, contractAddress, msg, memo) {
+    if (!this.walletAddress) {
+      throw new Error("Wallet address not found");
+    }
+    const msgExec = MsgExecuteContract.fromJSON({
+      contractAddress,
+      sender: senderAddress,
+      msg,
+      funds: []
+    });
+    const { txRaw } = createTransaction({
+      message: msgExec,
+      memo: "",
+      pubKey: Buffer.from(this.walletAddress).toString(),
+      sequence: 0,
+      accountNumber: 0,
+      chainId
+    });
+    const rawTx = {
+      from: senderAddress,
+      to: contractAddress,
+      signedDoc: {
+        bodyBytes: txRaw.bodyBytes,
+        chainId,
+        accountNumber: BigInt(0),
+        authInfoBytes: txRaw.authInfoBytes
+      }
+    };
+    return Promise.resolve(rawTx);
+  }
+  async getWalletAddress() {
+    if (!this.walletAddress) {
+      throw new Error("Wallet address not found");
+    }
+    return Promise.resolve(this.walletAddress);
+  }
+  async execute(senderAddress, contractAddress, msg, funds) {
+    if (!this.walletAddress) {
+      throw new Error("Wallet address not found");
+    }
+    const msgExec = MsgExecuteContractCompat.fromJSON({
+      contractAddress,
+      sender: senderAddress,
+      msg,
+      funds: funds || []
+    });
+    const txResult = await this.msgBroadcaster.broadcastWithFeeDelegation({
+      msgs: msgExec,
+      injectiveAddress: this.walletAddress
+    });
+    return InjectiveExecuteResponse.fromTxResponse(txResult);
+  }
+};
+function isPrivateKeySolanaWalletConfig(walletConfig) {
+  return "privateKey" in walletConfig;
+}
+function isBrowserExtensionSolanaWalletConfig(walletConfig) {
+  return "wallet" in walletConfig && !(walletConfig.wallet instanceof Keypair);
+}
+var SolanaWalletProvider = class {
+  wallet;
+  connection;
+  isAdapterMode;
+  constructor(walletConfig) {
+    if (isPrivateKeySolanaWalletConfig(walletConfig)) {
+      this.wallet = Keypair.fromSecretKey(walletConfig.privateKey);
+      this.connection = new Connection(walletConfig.endpoint, "confirmed");
+      this.isAdapterMode = false;
+    } else if (isBrowserExtensionSolanaWalletConfig(walletConfig)) {
+      this.wallet = walletConfig.wallet;
+      this.connection = walletConfig.connection;
+      this.isAdapterMode = true;
+    } else {
+      throw new Error("Invalid wallet configuration");
+    }
+  }
+  async waitForConfirmation(signature, commitment = "finalized") {
+    const latestBlockhash = await this.connection.getLatestBlockhash();
+    const response = await this.connection.confirmTransaction(
+      {
+        signature,
+        blockhash: latestBlockhash.blockhash,
+        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+      },
+      commitment
+    );
+    return response;
+  }
+  /**
+   * Send a raw transaction to the Solana network.
+   * @param rawTransaction - The raw transaction to send.
+   * @returns The transaction signature.
+   */
+  async sendTransaction(rawTransaction) {
+    return this.connection.sendRawTransaction(rawTransaction);
+  }
+  /**
+   * Send a raw transaction to the Solana network and wait for confirmation.
+   * @param rawTransaction - The raw transaction to send.
+   * @param commitment - The commitment level to use. Defaults to 'finalized'.
+   * @returns The transaction signature.
+   */
+  async sendTransactionWithConfirmation(rawTransaction, commitment = "finalized") {
+    const txHash = await this.connection.sendRawTransaction(rawTransaction);
+    await this.waitForConfirmation(txHash, commitment);
+    return txHash;
+  }
+  /**
+   * Build a v0 versioned transaction.
+   * @param instructions - The instructions to include in the transaction.
+   * @returns The v0 transaction.
+   */
+  async buildV0Txn(rawInstructions) {
+    if (this.isAdapterMode) {
+      return this.buildV0TxnWithAdapter(rawInstructions);
+    }
+    return this.buildV0TxnWithKeypair(rawInstructions);
+  }
+  async buildV0TxnWithAdapter(rawInstructions) {
+    const adapterWallet = this.wallet;
+    if (!adapterWallet.publicKey) {
+      throw new Error("Wallet public key is not initialized");
+    }
+    if (!adapterWallet.signTransaction) {
+      throw new Error("Wallet signTransaction is not initialized");
+    }
+    const instructions = this.buildTransactionInstruction(rawInstructions);
+    const latestBlockhash = await this.connection.getLatestBlockhash();
+    const messageV0 = new TransactionMessage({
+      payerKey: adapterWallet.publicKey,
+      recentBlockhash: latestBlockhash.blockhash,
+      instructions
+    }).compileToV0Message();
+    const tx = await adapterWallet.signTransaction(new VersionedTransaction(messageV0));
+    return tx.serialize();
+  }
+  async buildV0TxnWithKeypair(rawInstructions) {
+    const keypairWallet = this.wallet;
+    const instructions = this.buildTransactionInstruction(rawInstructions);
+    const messageV0 = new TransactionMessage({
+      payerKey: keypairWallet.publicKey,
+      recentBlockhash: (await this.connection.getLatestBlockhash()).blockhash,
+      instructions
+    }).compileToV0Message();
+    const tx = new VersionedTransaction(messageV0);
+    tx.sign([keypairWallet]);
+    return tx.serialize();
+  }
+  getWalletBase58PublicKey() {
+    if (!this.wallet.publicKey) {
+      throw new Error("Wallet public key is not initialized");
+    }
+    return this.wallet.publicKey.toBase58();
+  }
+  async getWalletAddress() {
+    return this.getWalletBase58PublicKey();
+  }
+  async getAssociatedTokenAddress(mint) {
+    if (!this.wallet.publicKey) {
+      throw new Error("Wallet public key is not initialized");
+    }
+    return (await getAssociatedTokenAddress(new PublicKey(mint), this.wallet.publicKey, true)).toBase58();
+  }
+  async getBalance(publicKey) {
+    return await this.connection.getBalance(new PublicKey(publicKey));
+  }
+  async getTokenAccountBalance(publicKey) {
+    return this.connection.getTokenAccountBalance(new PublicKey(publicKey));
+  }
+  buildTransactionInstruction(rawInstructions) {
+    return rawInstructions.map(
+      (rawInstruction) => new TransactionInstruction({
+        keys: rawInstruction.keys.map((key) => ({
+          pubkey: new PublicKey(key.pubkey),
+          isSigner: key.isSigner,
+          isWritable: key.isWritable
+        })),
+        programId: new PublicKey(rawInstruction.programId),
+        data: Buffer.from(rawInstruction.data)
+      })
+    );
+  }
+};
+var STELLAR_HORIZON_URLS = {
+  TESTNET: "https://horizon-testnet.stellar.org",
+  PUBLIC: "https://horizon.stellar.org"
+};
+var STELLAR_NETWORK_PASSPHRASES = {
+  TESTNET: Networks.TESTNET,
+  PUBLIC: Networks.PUBLIC
+};
+var TX_POLL_INTERVAL = 2e3;
+var TX_POLL_TIMEOUT = 6e4;
+var StellarWalletError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "StellarWalletError";
+  }
+};
+function isPrivateKeyStellarWalletConfig(config) {
+  return config.type === "PRIVATE_KEY";
+}
+function isBrowserExtensionStellarWalletConfig(config) {
+  return config.type === "BROWSER_EXTENSION";
+}
+function isStellarPkWallet(wallet) {
+  return wallet.type === "PRIVATE_KEY";
+}
+function isStellarBrowserExtensionWallet(wallet) {
+  return wallet.type === "BROWSER_EXTENSION";
+}
+function isValidStellarNetwork(network) {
+  return ["TESTNET", "PUBLIC"].includes(network);
+}
+function isValidStellarPrivateKey(privateKey) {
+  try {
+    const key = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+    Keypair$1.fromSecret(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var StellarWalletProvider = class {
+  wallet;
+  server;
+  networkPassphrase;
+  constructor(config) {
+    if (!isValidStellarNetwork(config.network)) {
+      throw new StellarWalletError(`Invalid network: ${config.network}`, "INVALID_NETWORK");
+    }
+    if (isPrivateKeyStellarWalletConfig(config)) {
+      if (!isValidStellarPrivateKey(config.privateKey)) {
+        throw new StellarWalletError("Invalid private key format", "INVALID_PRIVATE_KEY");
+      }
+      const privateKey = config.privateKey.startsWith("0x") ? config.privateKey.slice(2) : config.privateKey;
+      this.wallet = {
+        type: "PRIVATE_KEY",
+        keypair: Keypair$1.fromSecret(privateKey)
+      };
+      this.server = new Horizon.Server(config.rpcUrl ?? STELLAR_HORIZON_URLS[config.network]);
+      this.networkPassphrase = STELLAR_NETWORK_PASSPHRASES[config.network];
+      return;
+    }
+    if (isBrowserExtensionStellarWalletConfig(config)) {
+      this.wallet = {
+        type: "BROWSER_EXTENSION",
+        walletsKit: config.walletsKit
+      };
+      this.server = new Horizon.Server(config.rpcUrl ?? STELLAR_HORIZON_URLS[config.network]);
+      this.networkPassphrase = STELLAR_NETWORK_PASSPHRASES[config.network];
+      return;
+    }
+    throw new StellarWalletError("Invalid wallet configuration", "INVALID_CONFIG");
+  }
+  async getWalletAddress() {
+    try {
+      if (isStellarPkWallet(this.wallet)) {
+        return this.wallet.keypair.publicKey();
+      }
+      const { address } = await this.wallet.walletsKit.getAddress();
+      return address;
+    } catch (error) {
+      throw new StellarWalletError(
+        error instanceof Error ? error.message : "Failed to get wallet address",
+        "INVALID_CONFIG"
+      );
+    }
+  }
+  async signTransaction(tx) {
+    try {
+      if (isStellarPkWallet(this.wallet)) {
+        const transaction = new Transaction(tx, this.networkPassphrase);
+        transaction.sign(this.wallet.keypair);
+        return transaction.toXDR();
+      }
+      const { signedTxXdr } = await this.wallet.walletsKit.signTransaction(tx, {
+        networkPassphrase: this.networkPassphrase
+      });
+      return signedTxXdr;
+    } catch (error) {
+      throw new StellarWalletError(
+        error instanceof Error ? error.message : "Failed to sign transaction",
+        "SIGN_TX_ERROR"
+      );
+    }
+  }
+  async waitForTransactionReceipt(txHash) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < TX_POLL_TIMEOUT) {
+      try {
+        const tx = await this.server.transactions().transaction(txHash).call();
+        return {
+          ...tx,
+          _links: {
+            ...tx._links,
+            transaction: tx._links.self
+          }
+        };
+      } catch (error) {
+        await new Promise((resolve) => setTimeout(resolve, TX_POLL_INTERVAL));
+      }
+    }
+    throw new StellarWalletError(
+      `Transaction receipt not found for hash ${txHash} after ${TX_POLL_TIMEOUT / 1e3} seconds.`,
+      "TX_RECEIPT_TIMEOUT"
+    );
+  }
+};
+
+export { BigNumberToBigInt, EvmWalletProvider, IconWalletProvider, InjectiveWalletProvider, SolanaWalletProvider, StellarWalletError, StellarWalletProvider, SuiWalletProvider, getEvmViemChain, isBrowserExtensionEvmWalletConfig, isBrowserExtensionIconWalletConfig, isBrowserExtensionInjectiveWalletConfig, isBrowserExtensionStellarWalletConfig, isBrowserExtensionSuiWallet, isIconAddress, isIconBrowserExtensionWallet, isIconEoaAddress, isIconPkWallet, isJsonRpcPayloadResponse, isPkSuiWallet, isPrivateKeyEvmWalletConfig, isPrivateKeyIconWalletConfig, isPrivateKeyStellarWalletConfig, isResponseAddressType, isResponseSigningType, isStellarBrowserExtensionWallet, isStellarPkWallet, isSuiWallet, isValidStellarNetwork, isValidStellarPrivateKey, requestAddress, requestJsonRpc, requestSigning };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map