@openfort/openfort-node 0.9.2 → 0.10.0

package/dist/index.mjs

@@ -192,6 +192,15 @@ var AccountNotFoundError = class _AccountNotFoundError extends Error {
     }
   }
 };
+var DelegationError = class _DelegationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DelegationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _DelegationError);
+    }
+  }
+};
 var EncryptionError = class _EncryptionError extends Error {
   /**
    * Initializes a new EncryptionError instance.
@@ -375,7 +384,7 @@ function requiresWalletAuth(requestMethod, requestPath) {
 }
 
 // src/version.ts
-var VERSION = "0.9.2";
+var VERSION = "0.10.0";
 var PACKAGE = "@openfort/openfort-node";
 
 // src/openapi-client/openfortApiClient.ts
@@ -979,17 +988,6 @@ var verifyAuthToken = (params, options) => {
     options
   );
 };
-var authorize = (authorizePlayerRequest, options) => {
-  return openfortApiClient(
-    {
-      url: `/iam/v1/authorize`,
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      data: authorizePlayerRequest
-    },
-    options
-  );
-};
 
 // src/openapi-client/generated/auth/auth-v2/auth-v2.ts
 var auth_v2_exports = {};
@@ -1677,17 +1675,6 @@ var unlinkEmail = (unlinkEmailRequest, options) => {
     options
   );
 };
-var loginOIDC = (loginOIDCRequest, options) => {
-  return openfortApiClient(
-    {
-      url: `/iam/v1/oidc/login`,
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      data: loginOIDCRequest
-    },
-    options
-  );
-};
 var initOAuth = (oAuthInitRequest, options) => {
   return openfortApiClient(
     {
@@ -1793,16 +1780,6 @@ var me = (options) => {
 };
 
 // src/openapi-client/generated/backend-wallets/backend-wallets.ts
-var listBackendWallets = (params, options) => {
-  return openfortApiClient(
-    {
-      url: `/v2/accounts/backend`,
-      method: "GET",
-      params
-    },
-    options
-  );
-};
 var createBackendWallet = (createBackendWalletRequest, options) => {
   return openfortApiClient(
     {
@@ -1814,26 +1791,6 @@ var createBackendWallet = (createBackendWalletRequest, options) => {
     options
   );
 };
-var getBackendWallet = (id, options) => {
-  return openfortApiClient(
-    {
-      url: `/v2/accounts/backend/${id}`,
-      method: "GET"
-    },
-    options
-  );
-};
-var updateBackendWallet = (id, updateBackendWalletRequest, options) => {
-  return openfortApiClient(
-    {
-      url: `/v2/accounts/backend/${id}`,
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      data: updateBackendWalletRequest
-    },
-    options
-  );
-};
 var deleteBackendWallet = (id, options) => {
   return openfortApiClient(
     {
@@ -2893,23 +2850,6 @@ var CreateEmbeddedRequestChainType = {
   EVM: "EVM",
   SVM: "SVM"
 };
-var BackendWalletResponseObject = {
-  backendWallet: "backendWallet"
-};
-var BackendWalletResponseChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
-var BackendWalletResponseCustody = {
-  Developer: "Developer"
-};
-var BackendWalletListResponseObject = {
-  list: "list"
-};
-var BackendWalletListQueriesChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
 var CreateBackendWalletResponseObject = {
   account: "account"
 };
@@ -2921,27 +2861,6 @@ var CreateBackendWalletRequestChainType = {
   EVM: "EVM",
   SVM: "SVM"
 };
-var UpdateBackendWalletResponseObject = {
-  backendWallet: "backendWallet"
-};
-var UpdateBackendWalletResponseChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
-var UpdateBackendWalletResponseCustody = {
-  Developer: "Developer"
-};
-var UpdateBackendWalletResponseDelegatedAccountChainChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
-var UpdateBackendWalletRequestAccountType = {
-  Delegated_Account: "Delegated Account"
-};
-var UpdateBackendWalletRequestChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
 var DeleteBackendWalletResponseObject = {
   backendWallet: "backendWallet"
 };
@@ -3196,10 +3115,6 @@ var ListPoliciesScopeItem = {
   account: "account",
   transaction: "transaction"
 };
-var ListBackendWalletsChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
 var GetAccountsV2ChainType = {
   EVM: "EVM",
   SVM: "SVM"
@@ -3870,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);
@@ -3900,11 +3806,12 @@ async function signHash(options) {
 
 // src/wallets/evm/accounts/evmAccount.ts
 function toEvmAccount(data) {
-  const { id, address } = data;
+  const { id, address, walletId } = data;
   const account = {
     id,
     address,
     custody: "Developer",
+    walletId,
     async sign(parameters) {
       const result = await signHash({
         accountId: id,
@@ -3913,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 = {
@@ -3944,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;
@@ -3956,7 +3887,8 @@ function toEvmAccount(data) {
 function toEvmAccountData(response) {
   return {
     id: response.id,
-    address: response.address
+    address: response.address,
+    walletId: response.wallet
   };
 }
 var EvmClient = class {
@@ -3996,7 +3928,8 @@ var EvmClient = class {
     });
     return toEvmAccount({
       id: response.id,
-      address: response.address
+      address: response.address,
+      walletId: response.walletId
     });
   }
   /**
@@ -4024,13 +3957,17 @@ var EvmClient = class {
       );
     }
     if (options.id) {
-      const response = await getBackendWallet(options.id);
+      const response = await getAccountV2(options.id);
+      if (response.custody !== "Developer") {
+        throw new AccountNotFoundError();
+      }
       return toEvmAccount(toEvmAccountData(response));
     }
     if (options.address) {
-      const wallets = await listBackendWallets({
+      const wallets = await getAccountsV2({
         address: options.address,
         chainType: "EVM",
+        custody: "Developer",
         limit: 1
       });
       if (wallets.data.length === 0) {
@@ -4040,6 +3977,21 @@ 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,
+      accountType: "Delegated Account",
+      chainType: "EVM",
+      chainId: options.chainId
+    });
+    return response;
+  }
   /**
    * Lists all EVM backend wallets.
    *
@@ -4054,10 +4006,11 @@ var EvmClient = class {
    * ```
    */
   async listAccounts(options = {}) {
-    const response = await listBackendWallets({
+    const response = await getAccountsV2({
       limit: options.limit,
       skip: options.skip,
-      chainType: "EVM"
+      chainType: "EVM",
+      custody: "Developer"
     });
     const accounts = response.data.map(
       (wallet) => toEvmAccount(toEvmAccountData(wallet))
@@ -4104,7 +4057,8 @@ var EvmClient = class {
       });
       return toEvmAccount({
         id: response.id,
-        address: response.address
+        address: response.address,
+        walletId: response.walletId
       });
     } catch (error) {
       if (error instanceof UserInputValidationError) {
@@ -4161,34 +4115,204 @@ var EvmClient = class {
     });
     return response.signature;
   }
-  /**
-   * Updates an EVM backend wallet.
-   *
-   * Currently supports upgrading an EVM EOA to a Delegated Account (EIP-7702).
-   *
-   * @param options - Update options including account ID and delegation parameters
-   * @returns The updated backend wallet response
-   *
-   * @example
-   * ```typescript
-   * const updated = await openfort.accounts.evm.backend.update({
-   *   id: 'acc_...',
-   *   accountType: 'Delegated Account',
-   *   chain: { chainType: 'EVM', chainId: 8453 },
-   *   implementationType: 'Calibur',
-   * });
-   * ```
-   */
-  async update(options) {
-    const { id, ...req } = options;
-    return updateBackendWallet(id, req);
-  }
 };
 EvmClient.type = "evmWallet";
 
 // src/wallets/solana/solanaClient.ts
 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;
@@ -4211,6 +4335,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;
@@ -4231,6 +4499,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;
@@ -4308,13 +4582,14 @@ var SolanaClient = class {
       );
     }
     if (options.id) {
-      const response = await getBackendWallet(options.id);
+      const response = await getAccountV2(options.id);
       return toSolanaAccount(toSolanaAccountData(response));
     }
     if (options.address) {
-      const wallets = await listBackendWallets({
+      const wallets = await getAccountsV2({
         address: options.address,
         chainType: "SVM",
+        custody: "Developer",
         limit: 1
       });
       if (wallets.data.length === 0) {
@@ -4338,10 +4613,11 @@ var SolanaClient = class {
    * ```
    */
   async listAccounts(options = {}) {
-    const response = await listBackendWallets({
+    const response = await getAccountsV2({
       limit: options.limit,
       skip: options.skip,
-      chainType: "SVM"
+      chainType: "SVM",
+      custody: "Developer"
     });
     const accounts = response.data.map(
       (wallet) => toSolanaAccount(toSolanaAccountData(wallet))
@@ -4459,11 +4735,110 @@ 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/updateToDelegated.ts
+async function update(options) {
+  const { chainId, walletId, implementationType, accountId } = options;
+  return createAccountV2({
+    accountType: "Delegated Account",
+    chainType: "EVM",
+    chainId,
+    user: walletId,
+    implementationType,
+    account: accountId
+  });
+}
+
+// src/wallets/evm/actions/sendTransaction.ts
+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 ? 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.`
+    );
+  }
+  let signedAuthorization;
+  let txAccountId;
+  const response = await getAccountsV2({
+    address: viem.getAddress(account.address),
+    accountType: "Delegated Account",
+    chainType: "EVM",
+    chainId
+  });
+  if (response.data.length === 0) {
+    const updated = await update({
+      walletId: account.walletId,
+      chainId,
+      implementationType: "Calibur",
+      accountId: account.id
+    });
+    txAccountId = updated.id;
+    const implementationAddress = "0x000000009b1d0af20d8c6d0a44e162d11f9b8f00";
+    const publicClient = viem.createPublicClient({ chain, transport });
+    const eoaNonce = await publicClient.getTransactionCount({
+      address: account.address
+    });
+    const authHash = viemUtils.hashAuthorization({
+      contractAddress: implementationAddress,
+      chainId,
+      nonce: eoaNonce
+    });
+    signedAuthorization = await account.sign({ hash: authHash });
+  } else {
+    txAccountId = response.data[0].id;
+  }
+  const txIntent = await createTransactionIntent({
+    chainId,
+    account: txAccountId,
+    policy,
+    signedAuthorization,
+    interactions
+  });
+  if (!txIntent.nextAction?.payload?.signableHash) {
+    return txIntent;
+  }
+  const txSignature = await account.sign({
+    hash: txIntent.nextAction.payload.signableHash
+  });
+  return signature(txIntent.id, {
+    signature: txSignature
+  });
+}
+
 // src/policies/evmSchema.ts
 import { z } from "zod";
 var EthValueOperatorEnum = z.enum(["<=", ">=", "<", ">"]);
@@ -4769,19 +5144,6 @@ var UpdatePolicyBodySchema = z3.object({
   rules: z3.array(RuleSchema).min(1).max(10).optional()
 });
 
-// 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/index.ts
 function isValidSecretKey(key) {
   return key.startsWith("sk_test_") || key.startsWith("sk_live_");
@@ -4877,7 +5239,9 @@ var Openfort = class {
           /** Export private key (with E2E encryption) */
           export: evmClient.exportAccount.bind(evmClient),
           /** Update EOA to delegated account */
-          update: evmClient.update.bind(evmClient)
+          update,
+          /** Delegate + create + sign + submit a gasless transaction in one call */
+          sendTransaction: sendTransaction2
         },
         /** Embedded wallet operations (User custody) */
         embedded: {
@@ -4906,7 +5270,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: {
@@ -5097,10 +5467,14 @@ var Openfort = class {
    * gas costs are sponsored according to the policy's strategy.
    */
   get transactionIntents() {
+    if (!this._evmClient) {
+      this._evmClient = new EvmClient();
+    }
+    const _evmClient = this._evmClient;
     return {
       /** List transaction intents */
       list: getTransactionIntents,
-      /** Create a transaction intent with contract interactions */
+      /** Create a transaction intent with contract interactions. */
       create: createTransactionIntent,
       /** Get a transaction intent by ID */
       get: getTransactionIntent,
@@ -5245,9 +5619,7 @@ var Openfort = class {
         /** Verify auth token */
         verifyToken: verifyAuthToken,
         /** Verify OAuth token */
-        verifyOAuthToken,
-        /** Authorize */
-        authorize
+        verifyOAuthToken
       }
     };
   }
@@ -5455,11 +5827,6 @@ export {
   AuthProviderResponseV2,
   AuthenticateOAuthRequestProvider,
   AuthenticationType,
-  BackendWalletListQueriesChainType,
-  BackendWalletListResponseObject,
-  BackendWalletResponseChainType,
-  BackendWalletResponseCustody,
-  BackendWalletResponseObject,
   BasicAuthProvider,
   BasicAuthProviderEMAIL,
   BasicAuthProviderGUEST,
@@ -5487,6 +5854,7 @@ export {
   CriteriaOperatorNOTIN,
   CriteriaType,
   Currency,
+  DelegationError,
   DeleteBackendWalletResponseObject,
   DeveloperAccountResponseExpandable,
   EmailTypeRequest,
@@ -5571,7 +5939,6 @@ export {
   JsonRpcErrorResponseJsonrpc,
   JsonRpcRequestJsonrpc,
   JsonRpcSuccessResponseAnyJsonrpc,
-  ListBackendWalletsChainType,
   ListPoliciesScopeItem,
   MintAddressCriterionOperator,
   MintAddressCriterionRequestOperator,
@@ -5701,12 +6068,6 @@ export {
   TransactionIntentResponseExpandable,
   TransactionStatus,
   UnknownError,
-  UpdateBackendWalletRequestAccountType,
-  UpdateBackendWalletRequestChainType,
-  UpdateBackendWalletResponseChainType,
-  UpdateBackendWalletResponseCustody,
-  UpdateBackendWalletResponseDelegatedAccountChainChainType,
-  UpdateBackendWalletResponseObject,
   UpdatePolicyBodySchema,
   UsageAlertType,
   UserInputValidationError,
@@ -5719,7 +6080,6 @@ export {
   auth_v2_exports as authApi,
   openfortAuth_schemas_exports as authSchemas,
   authenticateSIWE,
-  authorize,
   callbackOAuth,
   cancelTransferAccountOwnership,
   configure,
@@ -5782,7 +6142,6 @@ export {
   getAuthPlayers,
   getAuthUser,
   getAuthUsers,
-  getBackendWallet,
   getConfig,
   getContract,
   getContracts,
@@ -5831,7 +6190,6 @@ export {
   linkSIWE,
   linkThirdParty,
   list,
-  listBackendWallets,
   listFeeSponsorships,
   listForwarderContracts,
   listOAuthConfig,
@@ -5839,7 +6197,6 @@ export {
   listPolicies,
   listSubscriptionLogs,
   loginEmailPassword,
-  loginOIDC,
   loginWithIdToken,
   logout,
   me,
@@ -5873,7 +6230,6 @@ export {
   unlinkEmail,
   unlinkOAuth,
   unlinkSIWE,
-  updateBackendWallet,
   updateContract,
   updateDeveloperAccount,
   updateFeeSponsorship,