@multiplatform.one/web3 7.17.0 → 7.19.0

package/dist/cjs/clients/solana.cjs

@@ -0,0 +1,322 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var solana_exports = {};
+__export(solana_exports, {
+  SolanaConfirmationError: () => SolanaConfirmationError,
+  connectSolanaWallet: () => connectSolanaWallet,
+  findSolanaSigner: () => findSolanaSigner,
+  injectedSolanaSigner: () => injectedSolanaSigner,
+  solanaChainFromRpcUrl: () => solanaChainFromRpcUrl,
+  solanaClient: () => solanaClient,
+  solanaRpcUrls: () => solanaRpcUrls,
+  standardSolanaSigner: () => standardSolanaSigner,
+  transferSolInstruction: () => transferSolInstruction
+});
+module.exports = __toCommonJS(solana_exports);
+var import_kit = require("@solana/kit");
+var import_types = require("./types.cjs");
+var import_walletStandard = require("./walletStandard.cjs");
+const solanaRpcUrls = {
+  "solana:mainnet": "https://api.mainnet-beta.solana.com",
+  "solana:devnet": "https://api.devnet.solana.com",
+  "solana:testnet": "https://api.testnet.solana.com",
+  "solana:localnet": "http://127.0.0.1:8899"
+};
+function solanaChainFromRpcUrl(rpcUrl) {
+  if (!rpcUrl) return "solana:mainnet";
+  if (/devnet/i.test(rpcUrl)) return "solana:devnet";
+  if (/testnet/i.test(rpcUrl)) return "solana:testnet";
+  if (/\/\/(localhost|127\.0\.0\.1|10\.0\.2\.2|\[::1\])[:/]/i.test(rpcUrl)) return "solana:localnet";
+  return "solana:mainnet";
+}
+class SolanaConfirmationError extends Error {
+  constructor(signature, reason, detail) {
+    const mayStillLand = reason === "timeout";
+    super(`solana transaction ${signature} ${detail}; ${mayStillLand ? "it may still land, so do not resend it until its blockhash expires" : "it will not land, so it is safe to retry"}`);
+    this.signature = signature;
+    this.reason = reason;
+    this.name = "SolanaConfirmationError";
+    this.mayStillLand = mayStillLand;
+  }
+  signature;
+  reason;
+  mayStillLand;
+}
+const capabilities = ["signMessage", "signTransaction", "signAndSendTransaction", "sendTransaction"];
+const systemProgram = (0, import_kit.address)("11111111111111111111111111111111");
+const maxU64 = 0xffffffffffffffffn;
+function transferSolInstruction(from, to, lamports) {
+  if (lamports < 0n || lamports > maxU64) {
+    throw new RangeError(`lamports must fit a u64, got ${lamports}`);
+  }
+  const data = new Uint8Array(12);
+  data[0] = 2;
+  let value = lamports;
+  for (let i = 4; i < 12; i++) {
+    data[i] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return {
+    programAddress: systemProgram,
+    accounts: [{
+      address: from,
+      role: import_kit.AccountRole.WRITABLE_SIGNER
+    }, {
+      address: to,
+      role: import_kit.AccountRole.WRITABLE
+    }],
+    data
+  };
+}
+const toWire = transaction => transaction instanceof Uint8Array ? transaction : Uint8Array.from((0, import_kit.getTransactionEncoder)().encode(transaction));
+const fromWire = bytes => (0, import_kit.getTransactionDecoder)().decode(bytes);
+const toSignature = bytes => (0, import_kit.getBase58Decoder)().decode(bytes);
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const lastValidBlockHeightOf = transaction => {
+  if (transaction instanceof Uint8Array) return void 0;
+  const lifetime = transaction.lifetimeConstraint;
+  return lifetime?.lastValidBlockHeight;
+};
+const reached = (status, commitment) => status?.confirmationStatus === "finalized" || commitment === "confirmed" && status?.confirmationStatus === "confirmed";
+function solanaClient(config) {
+  const {
+    signer
+  } = config;
+  const chain = config.chain ?? solanaChainFromRpcUrl(config.rpcUrl);
+  const rpc = config.rpc ?? (0, import_kit.createSolanaRpc)(config.rpcUrl ?? solanaRpcUrls[chain]);
+  const owner = (0, import_kit.address)(signer.address);
+  const signTransaction = async transaction => fromWire(await signer.signTransaction(toWire(transaction)));
+  const broadcast = transaction => {
+    const tx = transaction instanceof Uint8Array ? fromWire(transaction) : transaction;
+    return rpc.sendTransaction((0, import_kit.getBase64EncodedWireTransaction)(tx), {
+      encoding: "base64"
+    }).send();
+  };
+  const sendTransaction = async transaction => ({
+    signature: await broadcast(transaction),
+    lastValidBlockHeight: lastValidBlockHeightOf(transaction)
+  });
+  const signAndSendTransaction = async transaction => {
+    const lastValidBlockHeight = lastValidBlockHeightOf(transaction);
+    const wire = toWire(transaction);
+    if (signer.signAndSendTransaction) {
+      try {
+        const signature = toSignature(await signer.signAndSendTransaction(wire));
+        return {
+          signature,
+          lastValidBlockHeight
+        };
+      } catch (error) {
+        if (!(error instanceof import_types.UnsupportedClientMethodError)) throw error;
+      }
+    }
+    return {
+      signature: await broadcast(await signer.signTransaction(wire)),
+      lastValidBlockHeight
+    };
+  };
+  const statusOf = async signature => {
+    const {
+      value
+    } = await rpc.getSignatureStatuses([signature], {
+      searchTransactionHistory: true
+    }).send();
+    const status = value[0];
+    if (status?.err) {
+      throw new SolanaConfirmationError(signature, "failed", `failed on chain: ${JSON.stringify(status.err, (_, v) => typeof v === "bigint" ? `${v}` : v)}`);
+    }
+    return status;
+  };
+  return {
+    family: "solana",
+    address: owner,
+    chainId: chain,
+    capabilities,
+    rpc,
+    signer,
+    async signMessage(message) {
+      const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      return (0, import_kit.getBase58Decoder)().decode(await signer.signMessage(bytes));
+    },
+    signTransaction,
+    signAndSendTransaction,
+    sendTransaction,
+    async confirmTransaction(submission, options = {}) {
+      const {
+        signature,
+        lastValidBlockHeight: submitted
+      } = typeof submission === "string" ? {
+        signature: submission
+      } : submission;
+      const {
+        commitment = "confirmed",
+        lastValidBlockHeight = submitted,
+        timeoutMs = 9e4,
+        pollMs = 500
+      } = options;
+      const deadline = Date.now() + timeoutMs;
+      for (;;) {
+        if (reached(await statusOf(signature), commitment)) return;
+        if (lastValidBlockHeight !== void 0) {
+          const height = await rpc.getBlockHeight({
+            commitment
+          }).send();
+          if (height > lastValidBlockHeight) {
+            const status = await statusOf(signature);
+            if (reached(status, commitment)) return;
+            if (!status) {
+              throw new SolanaConfirmationError(signature, "expired", `expired: block height ${height} passed ${lastValidBlockHeight}`);
+            }
+          }
+        } else if (Date.now() > deadline) {
+          throw new SolanaConfirmationError(signature, "timeout", `not ${commitment} after ${timeoutMs}ms`);
+        }
+        await sleep(pollMs);
+      }
+    },
+    async getBalance(target) {
+      const {
+        value
+      } = await rpc.getBalance(target ? (0, import_kit.address)(target) : owner).send();
+      return value;
+    },
+    async transferSol({
+      to,
+      lamports
+    }) {
+      const {
+        value: latestBlockhash
+      } = await rpc.getLatestBlockhash().send();
+      const message = (0, import_kit.pipe)((0, import_kit.createTransactionMessage)({
+        version: 0
+      }), m => (0, import_kit.setTransactionMessageFeePayer)(owner, m), m => (0, import_kit.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, m), m => (0, import_kit.appendTransactionMessageInstruction)(transferSolInstruction(owner, (0, import_kit.address)(to), lamports), m));
+      const {
+        signature
+      } = await signAndSendTransaction((0, import_kit.compileTransaction)(message));
+      return {
+        signature,
+        lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
+      };
+    }
+  };
+}
+function walletFeature(wallet, name) {
+  const feature = wallet.features[name];
+  if (!feature) {
+    throw new import_types.UnsupportedClientMethodError("solana", name, `${wallet.name} does not implement it`);
+  }
+  return feature;
+}
+function standardSolanaSigner(wallet, account, chain = "solana:mainnet") {
+  const signer = {
+    address: account.address,
+    async signMessage(message) {
+      const feature = walletFeature(wallet, import_walletStandard.SolanaSignMessage);
+      const [output] = await feature.signMessage({
+        account,
+        message
+      });
+      return output.signature;
+    },
+    async signTransaction(transaction) {
+      const feature = walletFeature(wallet, import_walletStandard.SolanaSignTransaction);
+      const [output] = await feature.signTransaction({
+        account,
+        transaction,
+        chain
+      });
+      return output.signedTransaction;
+    }
+  };
+  if (wallet.features[import_walletStandard.SolanaSignAndSendTransaction]) {
+    signer.signAndSendTransaction = async transaction => {
+      const feature = walletFeature(wallet, import_walletStandard.SolanaSignAndSendTransaction);
+      const [output] = await feature.signAndSendTransaction({
+        account,
+        transaction,
+        chain
+      });
+      return output.signature;
+    };
+  }
+  return signer;
+}
+function findSolanaSigner(owner, chain) {
+  for (const wallet of (0, import_walletStandard.getSolanaWallets)()) {
+    const account = wallet.accounts.find(a => a.address === owner);
+    if (account) return standardSolanaSigner(wallet, account, chain);
+  }
+  return null;
+}
+async function connectSolanaWallet(options = {}) {
+  const wallets = (0, import_walletStandard.getSolanaWallets)();
+  const wallet = options.wallet ? wallets.find(w => w.name.toLowerCase() === options.wallet?.toLowerCase()) : wallets[0];
+  if (!wallet) {
+    throw new Error(options.wallet ? `No Solana wallet named ${options.wallet} is installed` : "No Solana wallet found. Install Phantom, Solflare or Backpack.");
+  }
+  const {
+    accounts
+  } = await walletFeature(wallet, import_walletStandard.StandardConnect).connect({
+    silent: options.silent
+  });
+  const chain = options.chain ?? "solana:mainnet";
+  const account = accounts.find(a => a.chains.includes(chain)) ?? accounts[0];
+  if (!account) throw new Error(`${wallet.name} returned no Solana account`);
+  return standardSolanaSigner(wallet, account, chain);
+}
+const utf8 = bytes => {
+  try {
+    return new TextDecoder("utf-8", {
+      fatal: true
+    }).decode(bytes);
+  } catch {
+    return null;
+  }
+};
+function injectedSolanaSigner(adapter, chain) {
+  const owner = adapter.address;
+  if (!owner) throw new Error("injectedSolanaSigner: connect a Solana wallet first");
+  const standard = method => {
+    const signer = findSolanaSigner(owner, chain);
+    if (!signer) {
+      throw new import_types.UnsupportedClientMethodError("solana", method, `no Wallet Standard wallet holds ${owner}; connect Phantom, Solflare or Backpack`);
+    }
+    return signer;
+  };
+  return {
+    address: owner,
+    async signMessage(message) {
+      const text = utf8(message);
+      if (text === null) return standard("signMessage").signMessage(message);
+      return Uint8Array.from((0, import_kit.getBase58Encoder)().encode(await adapter.signMessage(text)));
+    },
+    signTransaction: async transaction => standard("signTransaction").signTransaction(transaction),
+    async signAndSendTransaction(transaction) {
+      const signer = standard("signAndSendTransaction");
+      if (!signer.signAndSendTransaction) {
+        throw new import_types.UnsupportedClientMethodError("solana", "signAndSendTransaction");
+      }
+      return signer.signAndSendTransaction(transaction);
+    }
+  };
+}