@openfort/openfort-node 0.9.2 → 0.10.0

package/dist/index.js

@@ -50,11 +50,6 @@ __export(index_exports, {
   AuthProviderResponseV2: () => AuthProviderResponseV2,
   AuthenticateOAuthRequestProvider: () => AuthenticateOAuthRequestProvider,
   AuthenticationType: () => AuthenticationType,
-  BackendWalletListQueriesChainType: () => BackendWalletListQueriesChainType,
-  BackendWalletListResponseObject: () => BackendWalletListResponseObject,
-  BackendWalletResponseChainType: () => BackendWalletResponseChainType,
-  BackendWalletResponseCustody: () => BackendWalletResponseCustody,
-  BackendWalletResponseObject: () => BackendWalletResponseObject,
   BasicAuthProvider: () => BasicAuthProvider,
   BasicAuthProviderEMAIL: () => BasicAuthProviderEMAIL,
   BasicAuthProviderGUEST: () => BasicAuthProviderGUEST,
@@ -82,6 +77,7 @@ __export(index_exports, {
   CriteriaOperatorNOTIN: () => CriteriaOperatorNOTIN,
   CriteriaType: () => CriteriaType,
   Currency: () => Currency,
+  DelegationError: () => DelegationError,
   DeleteBackendWalletResponseObject: () => DeleteBackendWalletResponseObject,
   DeveloperAccountResponseExpandable: () => DeveloperAccountResponseExpandable,
   EmailTypeRequest: () => EmailTypeRequest,
@@ -166,7 +162,6 @@ __export(index_exports, {
   JsonRpcErrorResponseJsonrpc: () => JsonRpcErrorResponseJsonrpc,
   JsonRpcRequestJsonrpc: () => JsonRpcRequestJsonrpc,
   JsonRpcSuccessResponseAnyJsonrpc: () => JsonRpcSuccessResponseAnyJsonrpc,
-  ListBackendWalletsChainType: () => ListBackendWalletsChainType,
   ListPoliciesScopeItem: () => ListPoliciesScopeItem,
   MintAddressCriterionOperator: () => MintAddressCriterionOperator,
   MintAddressCriterionRequestOperator: () => MintAddressCriterionRequestOperator,
@@ -296,12 +291,6 @@ __export(index_exports, {
   TransactionIntentResponseExpandable: () => TransactionIntentResponseExpandable,
   TransactionStatus: () => TransactionStatus,
   UnknownError: () => UnknownError,
-  UpdateBackendWalletRequestAccountType: () => UpdateBackendWalletRequestAccountType,
-  UpdateBackendWalletRequestChainType: () => UpdateBackendWalletRequestChainType,
-  UpdateBackendWalletResponseChainType: () => UpdateBackendWalletResponseChainType,
-  UpdateBackendWalletResponseCustody: () => UpdateBackendWalletResponseCustody,
-  UpdateBackendWalletResponseDelegatedAccountChainChainType: () => UpdateBackendWalletResponseDelegatedAccountChainChainType,
-  UpdateBackendWalletResponseObject: () => UpdateBackendWalletResponseObject,
   UpdatePolicyBodySchema: () => UpdatePolicyBodySchema,
   UsageAlertType: () => UsageAlertType,
   UserInputValidationError: () => UserInputValidationError,
@@ -314,7 +303,6 @@ __export(index_exports, {
   authApi: () => auth_v2_exports,
   authSchemas: () => openfortAuth_schemas_exports,
   authenticateSIWE: () => authenticateSIWE,
-  authorize: () => authorize,
   callbackOAuth: () => callbackOAuth,
   cancelTransferAccountOwnership: () => cancelTransferAccountOwnership,
   configure: () => configure,
@@ -377,7 +365,6 @@ __export(index_exports, {
   getAuthPlayers: () => getAuthPlayers,
   getAuthUser: () => getAuthUser,
   getAuthUsers: () => getAuthUsers,
-  getBackendWallet: () => getBackendWallet,
   getConfig: () => getConfig,
   getContract: () => getContract,
   getContracts: () => getContracts,
@@ -426,7 +413,6 @@ __export(index_exports, {
   linkSIWE: () => linkSIWE,
   linkThirdParty: () => linkThirdParty,
   list: () => list,
-  listBackendWallets: () => listBackendWallets,
   listFeeSponsorships: () => listFeeSponsorships,
   listForwarderContracts: () => listForwarderContracts,
   listOAuthConfig: () => listOAuthConfig,
@@ -434,7 +420,6 @@ __export(index_exports, {
   listPolicies: () => listPolicies,
   listSubscriptionLogs: () => listSubscriptionLogs,
   loginEmailPassword: () => loginEmailPassword,
-  loginOIDC: () => loginOIDC,
   loginWithIdToken: () => loginWithIdToken,
   logout: () => logout,
   me: () => me,
@@ -468,7 +453,6 @@ __export(index_exports, {
   unlinkEmail: () => unlinkEmail,
   unlinkOAuth: () => unlinkOAuth,
   unlinkSIWE: () => unlinkSIWE,
-  updateBackendWallet: () => updateBackendWallet,
   updateContract: () => updateContract,
   updateDeveloperAccount: () => updateDeveloperAccount,
   updateFeeSponsorship: () => updateFeeSponsorship,
@@ -666,6 +650,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.
@@ -849,7 +842,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
@@ -1453,17 +1446,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 = {};
@@ -2151,17 +2133,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(
     {
@@ -2267,16 +2238,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(
     {
@@ -2288,26 +2249,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(
     {
@@ -3367,23 +3308,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"
 };
@@ -3395,27 +3319,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"
 };
@@ -3670,10 +3573,6 @@ var ListPoliciesScopeItem = {
   account: "account",
   transaction: "transaction"
 };
-var ListBackendWalletsChainType = {
-  EVM: "EVM",
-  SVM: "SVM"
-};
 var GetAccountsV2ChainType = {
   EVM: "EVM",
   SVM: "SVM"
@@ -4339,9 +4238,6 @@ var decryptExportedPrivateKey = (encryptedPrivateKeyBase64, privateKeyPem) => {
   return decrypted.toString("hex");
 };
 
-// src/wallets/evm/accounts/evmAccount.ts
-var import_viem = require("viem");
-
 // src/wallets/evm/actions/normalizeSignature.ts
 function normalizeSignature(sig) {
   const v = parseInt(sig.slice(-2), 16);
@@ -4363,11 +4259,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,
@@ -4376,29 +4273,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 = (0, import_viem.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 = (0, import_viem.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 = (0, import_viem.parseSignature)(response.signature);
-      const signedTransaction = (0, import_viem.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: (0, import_viem.getTypesForEIP712Domain)({ domain }),
+        EIP712Domain: viem.getTypesForEIP712Domain({ domain }),
         ...parameters.types
       };
       const openApiMessage = {
@@ -4407,9 +4328,9 @@ function toEvmAccount(data) {
         primaryType,
         message
       };
-      const hash = (0, import_viem.hashTypedData)(openApiMessage);
+      const hash = viem.hashTypedData(openApiMessage);
       const result = await sign(id, { data: hash });
-      return result.signature;
+      return normalizeSignature(result.signature);
     }
   };
   return account;
@@ -4419,7 +4340,8 @@ function toEvmAccount(data) {
 function toEvmAccountData(response) {
   return {
     id: response.id,
-    address: response.address
+    address: response.address,
+    walletId: response.wallet
   };
 }
 var EvmClient = class {
@@ -4459,7 +4381,8 @@ var EvmClient = class {
     });
     return toEvmAccount({
       id: response.id,
-      address: response.address
+      address: response.address,
+      walletId: response.walletId
     });
   }
   /**
@@ -4487,13 +4410,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) {
@@ -4503,6 +4430,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.
    *
@@ -4517,10 +4459,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))
@@ -4567,7 +4510,8 @@ var EvmClient = class {
       });
       return toEvmAccount({
         id: response.id,
-        address: response.address
+        address: response.address,
+        walletId: response.walletId
       });
     } catch (error) {
       if (error instanceof UserInputValidationError) {
@@ -4624,34 +4568,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
 var import_bs58 = __toESM(require("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;
@@ -4674,6 +4788,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;
@@ -4694,6 +4952,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;
@@ -4771,13 +5035,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) {
@@ -4801,10 +5066,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))
@@ -4922,11 +5188,110 @@ var SolanaClient = class {
     return response.signature;
   }
 };
+/** Wallet type identifier used for client registration */
 SolanaClient.type = "solanaWallet";
 
 // src/index.ts
 var import_shield_js2 = require("@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
 var import_zod = require("zod");
 var EthValueOperatorEnum = import_zod.z.enum(["<=", ">=", "<", ">"]);
@@ -5232,15 +5597,6 @@ var UpdatePolicyBodySchema = import_zod3.z.object({
   rules: import_zod3.z.array(RuleSchema).min(1).max(10).optional()
 });
 
-// src/wallets/evm/actions/signMessage.ts
-var import_viem2 = require("viem");
-
-// src/wallets/evm/actions/signTransaction.ts
-var import_viem3 = require("viem");
-
-// src/wallets/evm/actions/signTypedData.ts
-var import_viem4 = require("viem");
-
 // src/index.ts
 function isValidSecretKey(key) {
   return key.startsWith("sk_test_") || key.startsWith("sk_live_");
@@ -5336,7 +5692,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: {
@@ -5365,7 +5723,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: {
@@ -5556,10 +5920,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,
@@ -5704,9 +6072,7 @@ var Openfort = class {
         /** Verify auth token */
         verifyToken: verifyAuthToken,
         /** Verify OAuth token */
-        verifyOAuthToken,
-        /** Authorize */
-        authorize
+        verifyOAuthToken
       }
     };
   }
@@ -5915,11 +6281,6 @@ var index_default = Openfort;
   AuthProviderResponseV2,
   AuthenticateOAuthRequestProvider,
   AuthenticationType,
-  BackendWalletListQueriesChainType,
-  BackendWalletListResponseObject,
-  BackendWalletResponseChainType,
-  BackendWalletResponseCustody,
-  BackendWalletResponseObject,
   BasicAuthProvider,
   BasicAuthProviderEMAIL,
   BasicAuthProviderGUEST,
@@ -5947,6 +6308,7 @@ var index_default = Openfort;
   CriteriaOperatorNOTIN,
   CriteriaType,
   Currency,
+  DelegationError,
   DeleteBackendWalletResponseObject,
   DeveloperAccountResponseExpandable,
   EmailTypeRequest,
@@ -6031,7 +6393,6 @@ var index_default = Openfort;
   JsonRpcErrorResponseJsonrpc,
   JsonRpcRequestJsonrpc,
   JsonRpcSuccessResponseAnyJsonrpc,
-  ListBackendWalletsChainType,
   ListPoliciesScopeItem,
   MintAddressCriterionOperator,
   MintAddressCriterionRequestOperator,
@@ -6161,12 +6522,6 @@ var index_default = Openfort;
   TransactionIntentResponseExpandable,
   TransactionStatus,
   UnknownError,
-  UpdateBackendWalletRequestAccountType,
-  UpdateBackendWalletRequestChainType,
-  UpdateBackendWalletResponseChainType,
-  UpdateBackendWalletResponseCustody,
-  UpdateBackendWalletResponseDelegatedAccountChainChainType,
-  UpdateBackendWalletResponseObject,
   UpdatePolicyBodySchema,
   UsageAlertType,
   UserInputValidationError,
@@ -6179,7 +6534,6 @@ var index_default = Openfort;
   authApi,
   authSchemas,
   authenticateSIWE,
-  authorize,
   callbackOAuth,
   cancelTransferAccountOwnership,
   configure,
@@ -6241,7 +6595,6 @@ var index_default = Openfort;
   getAuthPlayers,
   getAuthUser,
   getAuthUsers,
-  getBackendWallet,
   getConfig,
   getContract,
   getContracts,
@@ -6290,7 +6643,6 @@ var index_default = Openfort;
   linkSIWE,
   linkThirdParty,
   list,
-  listBackendWallets,
   listFeeSponsorships,
   listForwarderContracts,
   listOAuthConfig,
@@ -6298,7 +6650,6 @@ var index_default = Openfort;
   listPolicies,
   listSubscriptionLogs,
   loginEmailPassword,
-  loginOIDC,
   loginWithIdToken,
   logout,
   me,
@@ -6332,7 +6683,6 @@ var index_default = Openfort;
   unlinkEmail,
   unlinkOAuth,
   unlinkSIWE,
-  updateBackendWallet,
   updateContract,
   updateDeveloperAccount,
   updateFeeSponsorship,