@openfort/openfort-node 0.9.3 → 0.10.1

package/dist/index.mjs

@@ -384,7 +384,7 @@ function requiresWalletAuth(requestMethod, requestPath) {
 }
 
 // src/version.ts
-var VERSION = "0.9.3";
+var VERSION = "0.10.1";
 var PACKAGE = "@openfort/openfort-node";
 
 // src/openapi-client/openfortApiClient.ts
@@ -3785,15 +3785,6 @@ var decryptExportedPrivateKey = (encryptedPrivateKeyBase64, privateKeyPem) => {
   return decrypted.toString("hex");
 };
 
-// src/wallets/evm/accounts/evmAccount.ts
-import {
-  getTypesForEIP712Domain,
-  hashTypedData,
-  parseSignature,
-  serializeTransaction,
-  toPrefixedMessage
-} from "viem";
-
 // src/wallets/evm/actions/normalizeSignature.ts
 function normalizeSignature(sig) {
   const v = parseInt(sig.slice(-2), 16);
@@ -3829,29 +3820,53 @@ function toEvmAccount(data) {
       return result.signature;
     },
     async signMessage(parameters) {
+      let viem;
+      try {
+        viem = await import("viem");
+      } catch {
+        throw new UserInputValidationError(
+          "`viem` is required for signMessage. Install it and try again."
+        );
+      }
       const { message } = parameters;
-      const preimage = toPrefixedMessage(message);
+      const preimage = viem.toPrefixedMessage(message);
       const result = await sign(id, { data: preimage });
-      return result.signature;
+      return normalizeSignature(result.signature);
     },
     async signTransaction(transaction) {
-      const serialized = serializeTransaction(transaction);
+      let viem;
+      try {
+        viem = await import("viem");
+      } catch {
+        throw new UserInputValidationError(
+          "`viem` is required for signTransaction. Install it and try again."
+        );
+      }
+      const serialized = viem.serializeTransaction(transaction);
       const response = await sign(id, { data: serialized });
-      const signature2 = parseSignature(response.signature);
-      const signedTransaction = serializeTransaction(
+      const signature2 = viem.parseSignature(response.signature);
+      const signedTransaction = viem.serializeTransaction(
         transaction,
         signature2
       );
       return signedTransaction;
     },
     async signTypedData(parameters) {
+      let viem;
+      try {
+        viem = await import("viem");
+      } catch {
+        throw new UserInputValidationError(
+          "`viem` is required for signTypedData. Install it and try again."
+        );
+      }
       const {
         domain = {},
         message,
         primaryType
       } = parameters;
       const types = {
-        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        EIP712Domain: viem.getTypesForEIP712Domain({ domain }),
         ...parameters.types
       };
       const openApiMessage = {
@@ -3860,9 +3875,9 @@ function toEvmAccount(data) {
         primaryType,
         message
       };
-      const hash = hashTypedData(openApiMessage);
+      const hash = viem.hashTypedData(openApiMessage);
       const result = await sign(id, { data: hash });
-      return result.signature;
+      return normalizeSignature(result.signature);
     }
   };
   return account;
@@ -3962,6 +3977,12 @@ var EvmClient = class {
     }
     throw new AccountNotFoundError();
   }
+  /**
+   * Retrieves delegated accounts linked to an EVM address on a specific chain.
+   *
+   * @param options - Options containing the address and chain ID
+   * @returns List of linked accounts
+   */
   async getLinkedAccounts(options) {
     const response = await getAccountsV2({
       address: options.address,
@@ -4098,8 +4119,201 @@ var EvmClient = class {
 EvmClient.type = "evmWallet";
 
 // src/wallets/solana/solanaClient.ts
+import { createPrivateKey, createPublicKey } from "crypto";
 import bs58 from "bs58";
 
+// src/wallets/solana/actions/constants.ts
+var USDC_MAINNET_MINT_ADDRESS = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var USDC_DEVNET_MINT_ADDRESS = "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
+var DEFAULT_COMPUTE_UNIT_LIMIT = 2e5;
+var DEFAULT_COMPUTE_UNIT_PRICE = 50000n;
+
+// src/wallets/solana/actions/utils.ts
+function getUsdcMintAddress(cluster) {
+  if (cluster === "mainnet-beta") {
+    return USDC_MAINNET_MINT_ADDRESS;
+  }
+  return USDC_DEVNET_MINT_ADDRESS;
+}
+function getRpcEndpoint(cluster) {
+  return cluster === "mainnet-beta" ? "https://api.mainnet-beta.solana.com" : "https://api.devnet.solana.com";
+}
+function getWsEndpoint(cluster) {
+  return cluster === "mainnet-beta" ? "wss://api.mainnet-beta.solana.com" : "wss://api.devnet.solana.com";
+}
+
+// src/wallets/solana/actions/sendTransaction.ts
+async function sendTransaction(options) {
+  const {
+    account,
+    cluster,
+    instructions,
+    computeUnitLimit,
+    computeUnitPrice,
+    rpcUrl,
+    wsUrl
+  } = options;
+  let solanaKit;
+  let computeBudget;
+  let transactionConfirmation;
+  let koraModule;
+  try {
+    solanaKit = await import("@solana/kit");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kit` is required for sendTransaction. Install it and try again."
+    );
+  }
+  try {
+    computeBudget = await import("@solana-program/compute-budget");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana-program/compute-budget` is required for sendTransaction. Install it and try again."
+    );
+  }
+  try {
+    koraModule = await import("@solana/kora");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kora` is required for sendTransaction. Install it and try again."
+    );
+  }
+  try {
+    transactionConfirmation = await import("@solana/transaction-confirmation");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/transaction-confirmation` is required for sendTransaction. Install it and try again."
+    );
+  }
+  const userAddress = solanaKit.address(account.address);
+  const clientConfig2 = getConfig();
+  if (!clientConfig2?.publishableKey) {
+    throw new MissingPublishableKeyError("sendTransaction");
+  }
+  const basePath = clientConfig2.basePath || "https://api.openfort.io";
+  const client = new koraModule.KoraClient({
+    rpcUrl: `${basePath}/rpc/solana/${cluster}`,
+    apiKey: `Bearer ${clientConfig2.publishableKey}`
+  });
+  const rpc = solanaKit.createSolanaRpc(rpcUrl ?? getRpcEndpoint(cluster));
+  const rpcSubscriptions = solanaKit.createSolanaRpcSubscriptions(
+    wsUrl ?? getWsEndpoint(cluster)
+  );
+  const confirmTransaction = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
+    rpc,
+    rpcSubscriptions
+  });
+  const { signer_address } = await client.getPayerSigner();
+  const blockhashResponse = await client.getBlockhash();
+  let txMsg = solanaKit.pipe(
+    solanaKit.createTransactionMessage({ version: 0 }),
+    (tx) => solanaKit.setTransactionMessageFeePayer(
+      solanaKit.address(signer_address),
+      tx
+    ),
+    // Kora's getBlockhash does not return lastValidBlockHeight, so we use 0n.
+    // Transaction expiry is handled by the confirmTransaction timeout instead.
+    (tx) => solanaKit.setTransactionMessageLifetimeUsingBlockhash(
+      {
+        blockhash: blockhashResponse.blockhash,
+        lastValidBlockHeight: 0n
+      },
+      tx
+    ),
+    (tx) => solanaKit.appendTransactionMessageInstructions(instructions, tx),
+    (tx) => computeBudget.updateOrAppendSetComputeUnitPriceInstruction(
+      computeUnitPrice ?? DEFAULT_COMPUTE_UNIT_PRICE,
+      tx
+    ),
+    (tx) => computeBudget.updateOrAppendSetComputeUnitLimitInstruction(
+      computeUnitLimit ?? DEFAULT_COMPUTE_UNIT_LIMIT,
+      tx
+    )
+  );
+  if (computeUnitLimit === void 0) {
+    const estimateComputeUnitLimit = computeBudget.estimateComputeUnitLimitFactory({ rpc });
+    try {
+      const estimatedLimit = await estimateComputeUnitLimit(txMsg);
+      txMsg = computeBudget.updateOrAppendSetComputeUnitLimitInstruction(
+        estimatedLimit,
+        txMsg
+      );
+    } catch {
+    }
+  }
+  const compiled = solanaKit.compileTransaction(txMsg);
+  const messageBase64 = Buffer.from(
+    compiled.messageBytes
+  ).toString("base64");
+  const signatureHex = await account.signTransaction({
+    transaction: messageBase64
+  });
+  const sigBytes = new Uint8Array(
+    Buffer.from(signatureHex.replace(/^0x/, ""), "hex")
+  );
+  const EMPTY_SIGNATURE = new Uint8Array(64);
+  const signatures = Object.fromEntries(
+    Object.entries(compiled.signatures).map(([addr]) => [
+      addr,
+      addr === userAddress ? sigBytes : EMPTY_SIGNATURE
+    ])
+  );
+  const signed = { ...compiled, signatures };
+  const base64Full = solanaKit.getBase64EncodedWireTransaction(signed);
+  const { signed_transaction } = await client.signTransaction({
+    transaction: base64Full,
+    signer_key: signer_address
+  });
+  const signature2 = await rpc.sendTransaction(
+    signed_transaction,
+    { encoding: "base64" }
+  ).send();
+  await confirmTransaction({
+    commitment: "confirmed",
+    signature: signature2,
+    abortSignal: AbortSignal.timeout(6e4)
+  });
+  return { signature: signature2 };
+}
+
+// src/wallets/solana/actions/sendRawTransaction.ts
+async function sendRawTransaction(options) {
+  const {
+    account,
+    cluster,
+    transaction,
+    computeUnitLimit,
+    computeUnitPrice,
+    rpcUrl,
+    wsUrl
+  } = options;
+  let solanaKit;
+  try {
+    solanaKit = await import("@solana/kit");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kit` is required for sendRawTransaction. Install it and try again."
+    );
+  }
+  const txBytes = new Uint8Array(Buffer.from(transaction, "base64"));
+  const decoded = solanaKit.getTransactionDecoder().decode(txBytes);
+  const compiledMessage = solanaKit.getCompiledTransactionMessageDecoder().decode(decoded.messageBytes);
+  const rpc = solanaKit.createSolanaRpc(rpcUrl ?? getRpcEndpoint(cluster));
+  const decompiled = await solanaKit.decompileTransactionMessageFetchingLookupTables(
+    compiledMessage,
+    rpc
+  );
+  return sendTransaction({
+    account,
+    cluster,
+    instructions: [...decompiled.instructions],
+    computeUnitLimit,
+    computeUnitPrice,
+    rpcUrl,
+    wsUrl
+  });
+}
+
 // src/wallets/solana/actions/signMessage.ts
 async function signMessage(options) {
   const { accountId, message } = options;
@@ -4122,6 +4336,150 @@ async function signTransaction(options) {
   };
 }
 
+// src/wallets/solana/actions/rpc.ts
+async function createRpcClient(cluster, rpcUrl) {
+  let solanaKit;
+  try {
+    solanaKit = await import("@solana/kit");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kit` is required. Install it and try again."
+    );
+  }
+  return solanaKit.createSolanaRpc(rpcUrl ?? getRpcEndpoint(cluster));
+}
+
+// src/wallets/solana/actions/transfer.ts
+async function transfer(options) {
+  const { account, cluster, rpcUrl, ...rest } = options;
+  const rpc = await createRpcClient(cluster, rpcUrl);
+  const instructions = !options.token || options.token.toLowerCase() === "sol" ? await getNativeTransferInstructions({
+    from: account.address,
+    to: options.to,
+    amount: options.amount
+  }) : await getSplTransferInstructions({
+    rpc,
+    from: account.address,
+    to: options.to,
+    mintAddress: options.token.toLowerCase() === "usdc" ? getUsdcMintAddress(cluster) : options.token,
+    amount: options.amount
+  });
+  return sendTransaction({
+    account,
+    cluster,
+    instructions,
+    rpcUrl,
+    computeUnitLimit: rest.computeUnitLimit,
+    computeUnitPrice: rest.computeUnitPrice,
+    wsUrl: rest.wsUrl
+  });
+}
+async function getNativeTransferInstructions({
+  from,
+  to,
+  amount
+}) {
+  let solanaKit;
+  let systemProgram;
+  try {
+    solanaKit = await import("@solana/kit");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kit` is required for transfer. Install it and try again."
+    );
+  }
+  try {
+    systemProgram = await import("@solana-program/system");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana-program/system` is required for SOL transfers. Install it and try again."
+    );
+  }
+  const fromAddr = solanaKit.address(from);
+  const toAddr = solanaKit.address(to);
+  return [
+    systemProgram.getTransferSolInstruction({
+      source: solanaKit.createNoopSigner(fromAddr),
+      destination: toAddr,
+      amount
+    })
+  ];
+}
+async function getSplTransferInstructions({
+  rpc,
+  from,
+  to,
+  mintAddress,
+  amount
+}) {
+  let solanaKit;
+  let tokenProgram;
+  try {
+    solanaKit = await import("@solana/kit");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana/kit` is required for transfer. Install it and try again."
+    );
+  }
+  try {
+    tokenProgram = await import("@solana-program/token");
+  } catch {
+    throw new UserInputValidationError(
+      "`@solana-program/token` is required for SPL transfers. Install it and try again."
+    );
+  }
+  const fromAddr = solanaKit.address(from);
+  const toAddr = solanaKit.address(to);
+  const mintAddr = solanaKit.address(mintAddress);
+  const mintInfo = await tokenProgram.fetchMint(rpc, mintAddr).catch(() => {
+    throw new UserInputValidationError(
+      `Failed to fetch mint account for ${mintAddress}. Verify the mint address is correct.`
+    );
+  });
+  const [sourceAta] = await tokenProgram.findAssociatedTokenPda({
+    mint: mintAddr,
+    owner: fromAddr,
+    tokenProgram: tokenProgram.TOKEN_PROGRAM_ADDRESS
+  });
+  const [destAta] = await tokenProgram.findAssociatedTokenPda({
+    mint: mintAddr,
+    owner: toAddr,
+    tokenProgram: tokenProgram.TOKEN_PROGRAM_ADDRESS
+  });
+  const sourceAcct = await tokenProgram.fetchToken(rpc, sourceAta).catch(() => {
+    throw new UserInputValidationError(
+      `Source account has no token account for mint ${mintAddress}`
+    );
+  });
+  if (sourceAcct.data.amount < amount) {
+    throw new UserInputValidationError(
+      `Insufficient token balance: have ${sourceAcct.data.amount}, need ${amount}`
+    );
+  }
+  const instructions = [];
+  const destAccountInfo = await rpc.getAccountInfo(destAta, { encoding: "base64" }).send();
+  if (!destAccountInfo.value) {
+    const createDestIx = await tokenProgram.getCreateAssociatedTokenInstructionAsync({
+      payer: solanaKit.createNoopSigner(fromAddr),
+      owner: toAddr,
+      ata: destAta,
+      mint: mintAddr
+    });
+    instructions.push(createDestIx);
+  }
+  instructions.push(
+    tokenProgram.getTransferCheckedInstruction({
+      source: sourceAta,
+      mint: mintAddr,
+      destination: destAta,
+      authority: solanaKit.createNoopSigner(fromAddr),
+      amount,
+      decimals: mintInfo.data.decimals
+    })
+  );
+  return instructions;
+}
+
 // src/wallets/solana/accounts/solanaAccount.ts
 function toSolanaAccount(data) {
   const { id, address } = data;
@@ -4142,6 +4500,12 @@ function toSolanaAccount(data) {
         transaction: parameters.transaction
       });
       return result.signedTransaction;
+    },
+    async transfer(options) {
+      return transfer({ ...options, account });
+    },
+    async sendRawTransaction(options) {
+      return sendRawTransaction({ ...options, account });
     }
   };
   return account;
@@ -4298,9 +4662,24 @@ var SolanaClient = class {
         );
       }
     }
-    if (privateKeyBytes.length === 64) {
-      privateKeyBytes = privateKeyBytes.slice(0, 32);
-    } else if (privateKeyBytes.length !== 32) {
+    if (privateKeyBytes.length === 32) {
+      const edPrivKey = createPrivateKey({
+        key: Buffer.concat([
+          Buffer.from(
+            // PKCS#8 DER prefix for Ed25519 (RFC 8410): 16 bytes wrapping a 32-byte seed
+            "302e020100300506032b657004220420",
+            "hex"
+          ),
+          privateKeyBytes
+        ]),
+        format: "der",
+        type: "pkcs8"
+      });
+      const rawPublicKey = createPublicKey(edPrivKey).export({ type: "spki", format: "der" }).subarray(-32);
+      privateKeyBytes = new Uint8Array(
+        Buffer.concat([privateKeyBytes, rawPublicKey])
+      );
+    } else if (privateKeyBytes.length !== 64) {
       throw new UserInputValidationError(
         "Private key must be 32 bytes (seed) or 64 bytes (full keypair)"
       );
@@ -4372,16 +4751,12 @@ var SolanaClient = class {
     return response.signature;
   }
 };
+/** Wallet type identifier used for client registration */
 SolanaClient.type = "solanaWallet";
 
 // src/index.ts
 import { ShieldAuthProvider as ShieldAuthProvider2 } from "@openfort/shield-js";
 
-// src/wallets/evm/actions/sendTransaction.ts
-import { createPublicClient, getAddress, http } from "viem";
-import * as chains from "viem/chains";
-import { hashAuthorization } from "viem/utils";
-
 // src/wallets/evm/actions/updateToDelegated.ts
 async function update(options) {
   const { chainId, walletId, implementationType, accountId } = options;
@@ -4396,11 +4771,37 @@ async function update(options) {
 }
 
 // src/wallets/evm/actions/sendTransaction.ts
-async function sendTransaction(options) {
+async function sendTransaction2(options) {
+  let viem;
+  let viemChains;
+  let viemUtils;
+  try {
+    viem = await import("viem");
+  } catch {
+    throw new UserInputValidationError(
+      "`viem` is required for sendTransaction. Install it and try again."
+    );
+  }
+  try {
+    viemChains = await import("viem/chains");
+  } catch {
+    throw new UserInputValidationError(
+      "`viem` is required for sendTransaction. Install it and try again."
+    );
+  }
+  try {
+    viemUtils = await import("viem/utils");
+  } catch {
+    throw new UserInputValidationError(
+      "`viem` is required for sendTransaction. Install it and try again."
+    );
+  }
   const { account, chainId, interactions, policy, rpcUrl } = options;
-  const transport = rpcUrl ? http(rpcUrl) : http();
-  const allChains = Object.values(chains);
-  const chain = allChains.find((c) => c.id === chainId);
+  const transport = rpcUrl ? viem.http(rpcUrl) : viem.http();
+  const allChains = Object.values(viemChains);
+  const chain = allChains.find(
+    (c) => typeof c === "object" && c !== null && "id" in c && c.id === chainId
+  );
   if (!chain) {
     throw new DelegationError(
       `Unknown chain ID ${chainId}. Provide a custom rpcUrl for unsupported chains.`
@@ -4409,7 +4810,7 @@ async function sendTransaction(options) {
   let signedAuthorization;
   let txAccountId;
   const response = await getAccountsV2({
-    address: getAddress(account.address),
+    address: viem.getAddress(account.address),
     accountType: "Delegated Account",
     chainType: "EVM",
     chainId
@@ -4423,11 +4824,11 @@ async function sendTransaction(options) {
     });
     txAccountId = updated.id;
     const implementationAddress = "0x000000009b1d0af20d8c6d0a44e162d11f9b8f00";
-    const publicClient = createPublicClient({ chain, transport });
+    const publicClient = viem.createPublicClient({ chain, transport });
     const eoaNonce = await publicClient.getTransactionCount({
       address: account.address
     });
-    const authHash = hashAuthorization({
+    const authHash = viemUtils.hashAuthorization({
       contractAddress: implementationAddress,
       chainId,
       nonce: eoaNonce
@@ -4454,19 +4855,6 @@ async function sendTransaction(options) {
   });
 }
 
-// src/wallets/evm/actions/signMessage.ts
-import { toHex, toPrefixedMessage as toPrefixedMessage2 } from "viem";
-
-// src/wallets/evm/actions/signTransaction.ts
-import {
-  keccak256,
-  parseSignature as parseSignature2,
-  serializeTransaction as serializeTransaction2
-} from "viem";
-
-// src/wallets/evm/actions/signTypedData.ts
-import { hashTypedData as hashTypedData2 } from "viem";
-
 // src/policies/evmSchema.ts
 import { z } from "zod";
 var EthValueOperatorEnum = z.enum(["<=", ">=", "<", ">"]);
@@ -4869,7 +5257,7 @@ var Openfort = class {
           /** Update EOA to delegated account */
           update,
           /** Delegate + create + sign + submit a gasless transaction in one call */
-          sendTransaction
+          sendTransaction: sendTransaction2
         },
         /** Embedded wallet operations (User custody) */
         embedded: {
@@ -4898,7 +5286,13 @@ var Openfort = class {
           /** Import private key (with E2E encryption) */
           import: solanaClient.importAccount.bind(solanaClient),
           /** Export private key (with E2E encryption) */
-          export: solanaClient.exportAccount.bind(solanaClient)
+          export: solanaClient.exportAccount.bind(solanaClient),
+          /** Send a gasless transaction via Kora */
+          sendTransaction,
+          /** Send a pre-built base64 transaction via Kora gasless flow */
+          sendRawTransaction,
+          /** Transfer SOL or SPL tokens (high-level) */
+          transfer
         },
         /** Embedded wallet operations (User custody) */
         embedded: {