@provablehq/aleo-bridge-sdk 0.1.0

package/dist/chunk-OU6GVGG7.js

@@ -0,0 +1,606 @@
+// src/errors/bridgeErrors.ts
+var BridgeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BridgeError";
+  }
+};
+
+// src/utils/xreserve.ts
+import {
+  encodeAbiParameters,
+  getAddress,
+  hexToBytes,
+  isAddress,
+  isHex,
+  keccak256,
+  padHex,
+  toHex
+} from "viem";
+var HOOK_DATA_BYTES = 65;
+var BECH32_ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function bech32Polymod(values) {
+  const generators = [996825010, 642813549, 513874426, 1027748829, 705979059];
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >>> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let index = 0; index < 5; index++) if (top >>> index & 1) checksum ^= generators[index];
+  }
+  return checksum >>> 0;
+}
+function decodeAleoBech32m(address) {
+  const separator = address.lastIndexOf("1");
+  const prefix = address.slice(0, separator);
+  const encoded = address.slice(separator + 1);
+  const words = [...encoded].map((character) => BECH32_ALPHABET.indexOf(character));
+  if (prefix !== "aleo" || separator < 1 || words.some((word) => word < 0)) throw new Error("invalid encoding");
+  const expanded = [...prefix].map((character) => character.charCodeAt(0) >>> 5).concat([0], [...prefix].map((character) => character.charCodeAt(0) & 31), words);
+  if (bech32Polymod(expanded) !== 734539939) throw new Error("invalid checksum");
+  const payload = words.slice(0, -6);
+  const bytes = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const word of payload) {
+    accumulator = accumulator << 5 | word;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      bytes.push(accumulator >>> bits & 255);
+    }
+  }
+  if (bits >= 5 || (accumulator << 8 - bits & 255) !== 0) throw new Error("invalid padding");
+  return Uint8Array.from(bytes);
+}
+function aleoAddressToBytes32(address) {
+  try {
+    if (!address.startsWith("aleo1") || address.length !== 63) throw new Error("invalid prefix or length");
+    const bytes = decodeAleoBech32m(address);
+    if (bytes.length !== 32) throw new Error("invalid payload");
+    return toHex(bytes);
+  } catch (cause) {
+    throw new BridgeError(`Invalid Aleo recipient address: ${address}`, { cause });
+  }
+}
+function bytes32ToAleoAddress(recipient) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(recipient)) {
+    throw new BridgeError(`Invalid 32-byte Aleo recipient: ${recipient}`);
+  }
+  const prefix = "aleo";
+  const words = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const byte of hexToBytes(recipient)) {
+    accumulator = accumulator << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      words.push(accumulator >>> bits & 31);
+    }
+  }
+  if (bits > 0) words.push(accumulator << 5 - bits & 31);
+  const expanded = [...prefix].map((character) => character.charCodeAt(0) >>> 5).concat([0], [...prefix].map((character) => character.charCodeAt(0) & 31));
+  const checksum = bech32Polymod([...expanded, ...words, 0, 0, 0, 0, 0, 0]) ^ 734539939;
+  for (let index = 0; index < 6; index++) {
+    words.push(checksum >>> 5 * (5 - index) & 31);
+  }
+  return `${prefix}1${words.map((word) => BECH32_ALPHABET[word]).join("")}`;
+}
+async function loadAleoSdk(environment) {
+  const moduleName = "@provablehq/sdk/dynamic.js";
+  try {
+    const sdk = await import(moduleName);
+    return sdk.loadNetwork(environment);
+  } catch (cause) {
+    throw new BridgeError("Private xReserve mints require the optional @provablehq/sdk package", { cause });
+  }
+}
+async function aleoProgramAddress(programId, environment) {
+  const sdk = await loadAleoSdk(environment);
+  return sdk.Address.fromProgramId(programId).to_string();
+}
+async function buildXReserveHookData(mode, recipient, environment, secretNonce = "0scalar") {
+  const bytes = new Uint8Array(HOOK_DATA_BYTES);
+  bytes[0] = mode === "public" ? 0 : mode === "record" ? 1 : 2;
+  if (mode === "private") {
+    const sdk = await loadAleoSdk(environment);
+    const bits = sdk.Plaintext.fromString(recipient).toBitsLe();
+    let scalar;
+    try {
+      scalar = sdk.Scalar.fromString(secretNonce);
+    } catch (cause) {
+      throw new BridgeError(`Invalid private mint secret nonce: ${secretNonce}`, { cause });
+    }
+    const commitment = new sdk.BHP256().commit(bits, scalar).toBytesLe();
+    if (commitment.length !== 32) throw new BridgeError("Private mint commitment must contain 32 bytes");
+    bytes.set(commitment, 1);
+  }
+  return toHex(bytes);
+}
+function calculateXReserveDepositNonce(sourceDomain, transactionHash, logIndex) {
+  const domain = encodeAbiParameters([{ type: "uint32" }], [sourceDomain]);
+  const index = encodeAbiParameters([{ type: "uint256" }], [BigInt(logIndex)]);
+  return keccak256(`0x${domain.slice(2)}${transactionHash.slice(2)}${index.slice(2)}`);
+}
+function uintBytes(value, bytes) {
+  if (value < 0n || value >= 1n << BigInt(bytes * 8)) throw new BridgeError(`Unsigned value does not fit in ${bytes} bytes`);
+  return hexToBytes(toHex(value, { size: bytes }));
+}
+function buildXReserveDepositPayload(params) {
+  if (!isHex(params.remoteToken, { strict: true }) || hexToBytes(params.remoteToken).length !== 32) throw new BridgeError("remoteToken must contain 32 bytes");
+  if (!isHex(params.remoteRecipient, { strict: true }) || hexToBytes(params.remoteRecipient).length !== 32) throw new BridgeError("remoteRecipient must contain 32 bytes");
+  if (!isHex(params.hookData, { strict: true }) || hexToBytes(params.hookData).length !== HOOK_DATA_BYTES) throw new BridgeError("hookData must contain 65 bytes");
+  if (!isAddress(params.localToken) || !isAddress(params.depositor)) throw new BridgeError("Payload EVM address is invalid");
+  const payload = new Uint8Array(305);
+  payload.set([90, 46, 10, 205, 0, 0, 0, 1], 0);
+  payload.set(uintBytes(params.amount, 32), 8);
+  payload.set(uintBytes(BigInt(params.remoteDomain), 4), 40);
+  payload.set(hexToBytes(params.remoteToken), 44);
+  payload.set(hexToBytes(params.remoteRecipient), 76);
+  payload.set(hexToBytes(padHex(getAddress(params.localToken), { size: 32 })), 108);
+  payload.set(hexToBytes(padHex(getAddress(params.depositor), { size: 32 })), 140);
+  payload.set(uintBytes(params.maxFee, 32), 172);
+  payload.set(hexToBytes(params.nonce), 204);
+  payload.set(uintBytes(BigInt(HOOK_DATA_BYTES), 4), 236);
+  payload.set(hexToBytes(params.hookData), 240);
+  return toHex(payload);
+}
+function calculateXReserveMessageHash(payload) {
+  return keccak256(payload);
+}
+function xReserveDepositNonceFromPayload(payload) {
+  if (!isHex(payload, { strict: true })) throw new BridgeError("xReserve payload must be prefixed hexadecimal");
+  const bytes = hexToBytes(payload);
+  if (bytes.length !== 305 || toHex(bytes.slice(0, 8)) !== "0x5a2e0acd00000001" || toHex(bytes.slice(236, 240)) !== "0x00000041") {
+    throw new BridgeError("xReserve payload has an invalid deposit layout");
+  }
+  return toHex(bytes.slice(204, 236));
+}
+function xReserveHexToAleoBytes(value, expectedBytes) {
+  if (!isHex(value, { strict: true })) throw new BridgeError("Aleo byte-array input must be prefixed hexadecimal");
+  const bytes = hexToBytes(value);
+  if (bytes.length !== expectedBytes) throw new BridgeError(`Aleo byte-array input must contain ${expectedBytes} bytes`);
+  return `[${[...bytes].map((byte) => `${byte}u8`).join(",")}]`;
+}
+function evmAddressToXReserveBytes32(address) {
+  if (!isAddress(address)) throw new BridgeError(`Invalid Ethereum recipient address: ${address}`);
+  return padHex(getAddress(address), { size: 32 });
+}
+
+// src/solana/igp.ts
+var TOKEN_EXCHANGE_RATE_SCALE = 10n ** 19n;
+var SOL_DECIMALS = 9;
+var INITIALIZED_BYTES = 1;
+var DISCRIMINATOR_BYTES = 8;
+var BUMP_SEED_BYTES = 1;
+var SALT_BYTES = 32;
+var PUBKEY_BYTES = 32;
+var ORACLE_COUNT_BYTES = 4;
+var GAS_ORACLE_ENTRY_BYTES = 38;
+var DOMAIN_BYTES = 4;
+var GAS_ORACLE_TAG_BYTES = 1;
+var EXCHANGE_RATE_BYTES = 16;
+var GAS_PRICE_BYTES = 16;
+function readUint128LE(view, offset) {
+  let value = 0n;
+  for (let index = EXCHANGE_RATE_BYTES - 1; index >= 0; index--) {
+    value = value << 8n | BigInt(view.getUint8(offset + index));
+  }
+  return value;
+}
+function quoteIgpGasPayment(params) {
+  const { igpAccountData } = params;
+  const view = new DataView(igpAccountData.buffer, igpAccountData.byteOffset, igpAccountData.byteLength);
+  const requireBytes = (offset2, length) => {
+    if (offset2 < 0 || length < 0 || offset2 + length > view.byteLength) {
+      throw new BridgeError("malformed Sealevel IGP account data: declared layout exceeds the supplied bytes");
+    }
+  };
+  let offset = INITIALIZED_BYTES + DISCRIMINATOR_BYTES + BUMP_SEED_BYTES + SALT_BYTES;
+  requireBytes(offset, 1);
+  const ownerOptionTag = view.getUint8(offset);
+  offset += 1;
+  if (ownerOptionTag !== 0 && ownerOptionTag !== 1) {
+    throw new BridgeError(`malformed Sealevel IGP account data: unsupported owner option tag ${ownerOptionTag}`);
+  }
+  if (ownerOptionTag === 1) {
+    requireBytes(offset, PUBKEY_BYTES);
+    offset += PUBKEY_BYTES;
+  }
+  requireBytes(offset, PUBKEY_BYTES + ORACLE_COUNT_BYTES);
+  offset += PUBKEY_BYTES;
+  const oracleCount = view.getUint32(offset, true);
+  offset += ORACLE_COUNT_BYTES;
+  for (let index = 0; index < oracleCount; index++) {
+    const entryStart = offset;
+    requireBytes(entryStart, GAS_ORACLE_ENTRY_BYTES);
+    const domain = view.getUint32(entryStart, true);
+    if (domain === params.destinationDomain) {
+      const tagOffset = entryStart + DOMAIN_BYTES;
+      const gasOracleTag = view.getUint8(tagOffset);
+      if (gasOracleTag !== 0) {
+        throw new BridgeError(
+          `Sealevel IGP account has an unexpected GasOracle variant tag ${gasOracleTag} for domain ${params.destinationDomain}; only variant 0 (RemoteGasData) is decoded`
+        );
+      }
+      const exchangeRateOffset = tagOffset + GAS_ORACLE_TAG_BYTES;
+      const gasPriceOffset = exchangeRateOffset + EXCHANGE_RATE_BYTES;
+      const decimalsOffset = gasPriceOffset + GAS_PRICE_BYTES;
+      const tokenExchangeRate = readUint128LE(view, exchangeRateOffset);
+      const gasPrice = readUint128LE(view, gasPriceOffset);
+      const tokenDecimals = view.getUint8(decimalsOffset);
+      const destinationCost = params.gasAmount * gasPrice;
+      const originCost = destinationCost * tokenExchangeRate / TOKEN_EXCHANGE_RATE_SCALE;
+      return SOL_DECIMALS >= tokenDecimals ? originCost * 10n ** BigInt(SOL_DECIMALS - tokenDecimals) : originCost / 10n ** BigInt(tokenDecimals - SOL_DECIMALS);
+    }
+    offset += GAS_ORACLE_ENTRY_BYTES;
+  }
+  throw new BridgeError(
+    `Sealevel IGP account has no gas-oracle entry for destination domain ${params.destinationDomain}`
+  );
+}
+
+// src/solana/kit.ts
+var kitModulePromise;
+async function loadKit() {
+  kitModulePromise ??= import("@solana/kit");
+  try {
+    return await kitModulePromise;
+  } catch (cause) {
+    throw new BridgeError(
+      "Solana support requires the optional peer dependency @solana/kit; install it with: pnpm add @solana/kit",
+      { cause }
+    );
+  }
+}
+
+// src/solana/transferRemote.ts
+import { hexToBytes as hexToBytes2 } from "viem";
+var PROGRAM_INSTRUCTION_DISCRIMINATOR = Uint8Array.of(1, 1, 1, 1, 1, 1, 1, 1);
+var TRANSFER_REMOTE_VARIANT_TAG = 1;
+var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+var DISPATCHED_MESSAGE_PDA_SEED_PREFIX = ["hyperlane", "-", "dispatched_message", "-"];
+var GAS_PAYMENT_PDA_SEED_PREFIX = ["hyperlane_igp", "-", "gas_payment", "-"];
+var INSTRUCTION_DATA_BYTES = 77;
+var U256_BYTES = 32;
+function writeU32LE(bytes, offset, value) {
+  bytes[offset] = value & 255;
+  bytes[offset + 1] = value >>> 8 & 255;
+  bytes[offset + 2] = value >>> 16 & 255;
+  bytes[offset + 3] = value >>> 24 & 255;
+}
+function writeU256LE(bytes, offset, value) {
+  if (value < 0n || value >= 1n << BigInt(U256_BYTES * 8)) {
+    throw new BridgeError(`amountLamports does not fit in a ${U256_BYTES}-byte unsigned integer`);
+  }
+  let remaining = value;
+  for (let index = 0; index < U256_BYTES; index++) {
+    bytes[offset + index] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+}
+async function buildTransferRemoteInstruction(params) {
+  const { metadata } = params;
+  const kit = await loadKit();
+  const addressEncoder = kit.getAddressEncoder();
+  const uniqueMessageBytes = addressEncoder.encode(kit.address(params.uniqueMessageAddress));
+  const [dispatchedMessagePda] = await kit.getProgramDerivedAddress({
+    programAddress: kit.address(metadata.mailboxProgramAddress),
+    seeds: [...DISPATCHED_MESSAGE_PDA_SEED_PREFIX, uniqueMessageBytes]
+  });
+  const [gasPaymentPda] = await kit.getProgramDerivedAddress({
+    programAddress: kit.address(metadata.igpProgramAddress),
+    seeds: [...GAS_PAYMENT_PDA_SEED_PREFIX, uniqueMessageBytes]
+  });
+  const data = new Uint8Array(INSTRUCTION_DATA_BYTES);
+  data.set(PROGRAM_INSTRUCTION_DISCRIMINATOR, 0);
+  data[8] = TRANSFER_REMOTE_VARIANT_TAG;
+  writeU32LE(data, 9, metadata.destinationDomain);
+  data.set(hexToBytes2(aleoAddressToBytes32(params.recipientAleoAddress)), 13);
+  writeU256LE(data, 45, params.amountLamports);
+  const accounts = [
+    { address: SYSTEM_PROGRAM_ADDRESS, signer: false, writable: false },
+    // row 0
+    { address: metadata.splNoopProgramAddress, signer: false, writable: false },
+    // row 1
+    { address: metadata.tokenPda, signer: false, writable: false },
+    // row 2
+    { address: metadata.mailboxProgramAddress, signer: false, writable: false },
+    // row 3
+    { address: metadata.mailboxOutboxPda, signer: false, writable: true },
+    // row 4
+    { address: metadata.dispatchAuthorityPda, signer: false, writable: false },
+    // row 5
+    { address: params.senderAddress, signer: true, writable: true },
+    // row 6
+    { address: params.uniqueMessageAddress, signer: true, writable: false },
+    // row 7
+    { address: dispatchedMessagePda, signer: false, writable: true },
+    // row 8
+    { address: metadata.igpProgramAddress, signer: false, writable: false },
+    // row 9
+    { address: metadata.igpProgramDataPda, signer: false, writable: true },
+    // row 10
+    { address: gasPaymentPda, signer: false, writable: true },
+    // row 11
+    // row 12 (optional): only present when the route wraps its IGP in an
+    // `OverheadIgp` — omitted entirely otherwise (SEALEVEL_NOTES.md §2 row
+    // 12, "optional slot").
+    ...metadata.igpOverheadAccount ? [{ address: metadata.igpOverheadAccount, signer: false, writable: false }] : [],
+    { address: metadata.igpAccount, signer: false, writable: true },
+    // row 13
+    { address: SYSTEM_PROGRAM_ADDRESS, signer: false, writable: false },
+    // row 14
+    { address: metadata.nativeCollateralPda, signer: false, writable: true }
+    // row 15
+  ];
+  return { programAddress: metadata.warpProgramAddress, accounts, data };
+}
+
+// src/solana/rpc.ts
+function decodeBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function createSolanaRpcClient(config) {
+  async function call(method, params) {
+    const transport = config.transport ?? globalThis.fetch;
+    const response = await transport(config.url, {
+      method: "POST",
+      headers: { "content-type": "application/json", "cache-control": "no-cache" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new BridgeError(`Solana RPC ${method} request failed with HTTP status ${response.status}`, {
+        cause: { status: response.status }
+      });
+    }
+    let rawBody;
+    try {
+      rawBody = await response.json();
+    } catch (error) {
+      throw new BridgeError(`Solana RPC ${method} returned invalid JSON`, { cause: error });
+    }
+    if (!rawBody || typeof rawBody !== "object") {
+      throw new BridgeError(`Solana RPC ${method} returned an invalid JSON-RPC response`);
+    }
+    const body = rawBody;
+    if (body.error) {
+      throw new BridgeError(`Solana RPC ${method} returned a JSON-RPC error: ${body.error.message ?? "unknown error"}`, {
+        cause: body.error
+      });
+    }
+    if (!Object.prototype.hasOwnProperty.call(body, "result") || body.result === void 0) {
+      throw new BridgeError(`Solana RPC ${method} returned an invalid result envelope`);
+    }
+    return body.result;
+  }
+  function integer(method, value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+      throw new BridgeError(`Solana RPC ${method} returned an invalid result`);
+    }
+    return BigInt(value);
+  }
+  function contextualValue(method, result) {
+    if (!result || typeof result !== "object" || !Object.prototype.hasOwnProperty.call(result, "value")) {
+      throw new BridgeError(`Solana RPC ${method} returned an invalid contextual result`);
+    }
+    return result.value;
+  }
+  return {
+    async getLatestBlockhash() {
+      const result = await call(
+        "getLatestBlockhash",
+        [{ commitment: "confirmed" }]
+      );
+      const value = contextualValue("getLatestBlockhash", result);
+      if (!value || typeof value.blockhash !== "string" || !value.blockhash) {
+        throw new BridgeError("Solana RPC getLatestBlockhash returned an invalid result");
+      }
+      return { blockhash: value.blockhash, lastValidBlockHeight: integer("getLatestBlockhash", value.lastValidBlockHeight) };
+    },
+    async getBlockHeight() {
+      return integer("getBlockHeight", await call("getBlockHeight", []));
+    },
+    async isBlockhashValid(blockhash) {
+      const result = await call("isBlockhashValid", [blockhash, { commitment: "confirmed" }]);
+      const value = contextualValue("isBlockhashValid", result);
+      if (typeof value !== "boolean") {
+        throw new BridgeError("Solana RPC isBlockhashValid returned an invalid result");
+      }
+      return value;
+    },
+    async getBalance(address) {
+      const value = contextualValue("getBalance", await call("getBalance", [address]));
+      return integer("getBalance", value);
+    },
+    async getFeeForMessage(message) {
+      const base64 = btoa(String.fromCharCode(...message));
+      const result = await call("getFeeForMessage", [base64, { commitment: "confirmed" }]);
+      return integer("getFeeForMessage", contextualValue("getFeeForMessage", result));
+    },
+    async getMinimumBalanceForRentExemption(dataLength) {
+      if (!Number.isSafeInteger(dataLength) || dataLength < 0) {
+        throw new BridgeError("Solana rent data length must be a non-negative integer");
+      }
+      return integer("getMinimumBalanceForRentExemption", await call("getMinimumBalanceForRentExemption", [dataLength]));
+    },
+    async getAccountData(address) {
+      const result = await call("getAccountInfo", [
+        address,
+        { encoding: "base64" }
+      ]);
+      const value = contextualValue("getAccountInfo", result);
+      if (!value) return null;
+      if (!Array.isArray(value.data) || typeof value.data[0] !== "string" || value.data[1] !== "base64") {
+        throw new BridgeError("Solana RPC getAccountInfo returned invalid base64 account data");
+      }
+      try {
+        return decodeBase64(value.data[0]);
+      } catch (error) {
+        throw new BridgeError("Solana RPC getAccountInfo returned invalid base64 account data", { cause: error });
+      }
+    },
+    async getSignatureStatus(signature) {
+      const result = await call(
+        "getSignatureStatuses",
+        [[signature], { searchTransactionHistory: true }]
+      );
+      const value = contextualValue("getSignatureStatuses", result);
+      if (!Array.isArray(value) || value.length !== 1) {
+        throw new BridgeError("Solana RPC getSignatureStatuses returned an invalid result");
+      }
+      const status = value[0];
+      if (!status) return null;
+      if (typeof status !== "object" || !Object.prototype.hasOwnProperty.call(status, "err")) {
+        throw new BridgeError("Solana RPC getSignatureStatuses returned an invalid status");
+      }
+      if (status.err) return "failed";
+      if (status.confirmationStatus === void 0) return null;
+      if (!["processed", "confirmed", "finalized"].includes(status.confirmationStatus)) {
+        throw new BridgeError(`Solana RPC getSignatureStatuses returned unsupported confirmation status: ${status.confirmationStatus}`);
+      }
+      return status.confirmationStatus;
+    },
+    async getTransactionLogs(signature) {
+      const result = await call("getTransaction", [
+        signature,
+        { maxSupportedTransactionVersion: 0, commitment: "confirmed" }
+      ]);
+      if (result === null) return null;
+      if (!result || typeof result !== "object" || !Object.prototype.hasOwnProperty.call(result, "meta")) {
+        throw new BridgeError("Solana RPC getTransaction returned an invalid result");
+      }
+      const meta = result.meta;
+      if (!meta || typeof meta !== "object" || !Object.prototype.hasOwnProperty.call(meta, "logMessages")) {
+        throw new BridgeError("Solana RPC getTransaction returned invalid metadata");
+      }
+      const logs = meta.logMessages;
+      if (logs !== null && (!Array.isArray(logs) || logs.some((line) => typeof line !== "string"))) {
+        throw new BridgeError("Solana RPC getTransaction returned invalid logs");
+      }
+      return logs ?? null;
+    }
+  };
+}
+
+// src/connections/solana.ts
+import bs58 from "bs58";
+var SOLANA_SIGN_AND_SEND_TRANSACTION_FEATURE = "solana:signAndSendTransaction";
+var DEFAULT_SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com";
+function solanaHttp(url, options = {}) {
+  return { type: "http", url, fetch: options.fetch };
+}
+function solanaCustom(request) {
+  return { type: "custom", request };
+}
+function solanaWallet(params) {
+  return { type: "wallet", ...params };
+}
+function solanaKeyPair(secretKeyBytes) {
+  if (secretKeyBytes.length !== 64) throw new BridgeError("Solana secret key must contain exactly 64 bytes");
+  return { type: "local", secretKeyBytes: new Uint8Array(secretKeyBytes) };
+}
+function createSolanaClient(config) {
+  if (!config.transport) throw new BridgeError("Solana client requires a transport");
+  return materializeSolanaClient(config, globalThis.fetch);
+}
+function materializeSolanaClient(config, defaultFetch) {
+  const transportDefinition = config.transport;
+  const httpTransport = transportDefinition.type === "http" ? transportDefinition.fetch ?? defaultFetch : async (_url, init) => {
+    const body = JSON.parse(init.body);
+    return { ok: true, status: 200, json: async () => ({ result: await transportDefinition.request(body.method, body.params) }) };
+  };
+  const url = transportDefinition.type === "http" ? transportDefinition.url : "solana:custom";
+  const rpcClient = createSolanaRpcClient({ url, transport: httpTransport });
+  const publicClient = {
+    ...rpcClient,
+    async sendTransaction(signedTransaction) {
+      const base64 = btoa(String.fromCharCode(...signedTransaction));
+      const sendOptions = { encoding: "base64", preflightCommitment: "confirmed" };
+      if (transportDefinition.type === "custom") {
+        const signature = await transportDefinition.request("sendTransaction", [base64, sendOptions]);
+        if (typeof signature !== "string" || !signature) throw new BridgeError("Solana RPC sendTransaction returned an invalid signature");
+        return { signature };
+      }
+      const response = await httpTransport(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", "cache-control": "no-cache" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "sendTransaction", params: [base64, sendOptions] }),
+        cache: "no-store"
+      });
+      const body = await response.json();
+      if (!response.ok || body.error || typeof body.result !== "string" || !body.result) {
+        const details = body.error?.data === void 0 ? "" : `; ${JSON.stringify(body.error.data)}`;
+        throw new BridgeError(`Solana RPC sendTransaction failed: ${body.error?.message ?? `HTTP ${response.status}`}${details}`);
+      }
+      return { signature: body.result };
+    }
+  };
+  let walletClient;
+  if (config.account?.type === "wallet") {
+    const walletAccount = config.account;
+    const feature = walletAccount.wallet.features[SOLANA_SIGN_AND_SEND_TRANSACTION_FEATURE];
+    if (!feature) throw new BridgeError(`Connected wallet does not expose the '${SOLANA_SIGN_AND_SEND_TRANSACTION_FEATURE}' feature`);
+    walletClient = {
+      getAddress: async () => walletAccount.account.address,
+      sendTransaction: async (transaction) => {
+        const [output] = await feature.signAndSendTransaction({
+          transaction,
+          account: walletAccount.account,
+          chain: walletAccount.chain
+        });
+        if (!output) throw new BridgeError("Wallet returned no signAndSendTransaction result");
+        return { signature: bs58.encode(output.signature) };
+      }
+    };
+  } else if (config.account?.type === "local") {
+    let signerPromise;
+    const create = () => signerPromise ??= createSigner(config.account.type === "local" ? config.account.secretKeyBytes : new Uint8Array());
+    walletClient = {
+      getAddress: async () => (await create()).address,
+      sendTransaction: async (wireTransaction) => {
+        const kit = await loadKit();
+        const signer = await create();
+        const transaction = kit.getTransactionDecoder().decode(wireTransaction);
+        const signed = await kit.partiallySignTransaction([signer.keyPair], transaction);
+        return publicClient.sendTransaction(new Uint8Array(kit.getTransactionEncoder().encode(signed)));
+      }
+    };
+  }
+  return { family: "solana", publicClient, walletClient };
+}
+async function createSigner(secretKeyBytes) {
+  const kit = await loadKit();
+  return kit.createKeyPairSignerFromBytes(secretKeyBytes);
+}
+
+export {
+  BridgeError,
+  aleoAddressToBytes32,
+  bytes32ToAleoAddress,
+  aleoProgramAddress,
+  buildXReserveHookData,
+  calculateXReserveDepositNonce,
+  buildXReserveDepositPayload,
+  calculateXReserveMessageHash,
+  xReserveDepositNonceFromPayload,
+  xReserveHexToAleoBytes,
+  evmAddressToXReserveBytes32,
+  quoteIgpGasPayment,
+  loadKit,
+  buildTransferRemoteInstruction,
+  createSolanaRpcClient,
+  DEFAULT_SOLANA_RPC_URL,
+  solanaHttp,
+  solanaCustom,
+  solanaWallet,
+  solanaKeyPair,
+  createSolanaClient
+};
+//# sourceMappingURL=chunk-OU6GVGG7.js.map