@capxul/sdk 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/client.cjs

@@ -72,9 +72,79 @@ function fromConvexError(error) {
 // src/core/accounts.ts
 function createAccountsClient(config = {}) {
   return {
-    retrieve: async () => stub("accounts.retrieve"),
+    retrieve: async (accountId) => {
+      if (!config.data) {
+        return stub("accounts.retrieve");
+      }
+      try {
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (account.id !== accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.retrieve currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: accountId,
+                authenticatedAccountId: account.id
+              }
+            }),
+            null
+          ];
+        }
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     lookup: async () => stub("accounts.lookup"),
-    update: async () => stub("accounts.update"),
+    update: async (input) => {
+      if (!config.data) {
+        return stub("accounts.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "accounts.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        const current = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (current.id !== input.accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.update currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: input.accountId,
+                authenticatedAccountId: current.id
+              }
+            }),
+            null
+          ];
+        }
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const updated = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, updated];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     provisionPersonal: async (input) => {
       if (!config.data) {
         return stub(
@@ -697,7 +767,34 @@ function createMeClient(config = {}) {
         return [fromConvexError(cause), null];
       }
     },
-    update: async () => stub("me.update")
+    update: async (input) => {
+      if (!config.data) {
+        return stub("me.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "me.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
   };
 }
 
@@ -1506,6 +1603,96 @@ function createSubAccountsClient() {
   };
 }
 
+// src/core/token-transfers.ts
+var toTokenTransferId = (raw) => {
+  if (typeof raw !== "string" || raw.length === 0) {
+    throw new Error(
+      `Invalid tokenTransferId: expected non-empty string, got ${String(raw)}`
+    );
+  }
+  return raw;
+};
+function brandRow(row) {
+  return {
+    ...row,
+    id: toTokenTransferId(row.id)
+  };
+}
+function createTokenTransfersClient(config = {}) {
+  return {
+    list: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.list");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.list,
+          {
+            limit: input?.limit,
+            cursor: input?.cursor,
+            direction: input?.direction
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_AUTHENTICATED",
+              message: "tokenTransfers.list requires an authenticated session."
+            }),
+            null
+          ];
+        }
+        return [
+          null,
+          {
+            object: "list",
+            data: raw.items.map(brandRow),
+            page: {
+              hasMore: raw.hasMore,
+              nextCursor: raw.nextCursor
+            },
+            displayCurrency: raw.displayCurrency
+          }
+        ];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
+    retrieve: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.retrieve");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.getByTxLogIndex,
+          {
+            txHash: input.txHash,
+            logIndex: input.logIndex,
+            chainId: input.chainId
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_FOUND",
+              message: `tokenTransfer (txHash=${input.txHash}, logIndex=${input.logIndex}) not found or not visible to caller.`,
+              details: {
+                txHash: input.txHash,
+                logIndex: input.logIndex,
+                chainId: input.chainId
+              }
+            }),
+            null
+          ];
+        }
+        return [null, brandRow(raw)];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
+  };
+}
+
 // src/core/virtual-accounts.ts
 function createVirtualAccountsClient() {
   return {
@@ -2249,6 +2436,7 @@ function createCapxulClient(config = {}) {
     organizations: createOrganizationsClient(config),
     payments: createPaymentsClient(config),
     transfers: createTransfersClient(),
+    tokenTransfers: createTokenTransfersClient(config),
     withdrawals: createWithdrawalsClient(config),
     documents: createDocumentsClient(),
     subAccounts: createSubAccountsClient(),

package/dist/client.d.cts

@@ -1,6 +1,6 @@
 import 'viem';
 import 'xstate';
-export { f as CapxulAuthConfig, C as CapxulClient, g as CapxulConfig, h as CapxulDataClient, i as CapxulFlowFactories, j as CapxulSigningConfig, y as createCapxulClient } from './client-D-0KTn8D.cjs';
+export { f as CapxulAuthConfig, C as CapxulClient, g as CapxulConfig, h as CapxulDataClient, i as CapxulFlowFactories, j as CapxulSigningConfig, K as createCapxulClient } from './client-CXRKtbfn.cjs';
 import './next-action-DkrwXYay.cjs';
 import './errors-GgKrSUKp.cjs';
 import './types-DVWojoy4.cjs';

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import 'viem';
 import 'xstate';
-export { f as CapxulAuthConfig, C as CapxulClient, g as CapxulConfig, h as CapxulDataClient, i as CapxulFlowFactories, j as CapxulSigningConfig, y as createCapxulClient } from './client-CweJSkaY.js';
+export { f as CapxulAuthConfig, C as CapxulClient, g as CapxulConfig, h as CapxulDataClient, i as CapxulFlowFactories, j as CapxulSigningConfig, K as createCapxulClient } from './client-CcCtq5XO.js';
 import './next-action-DkrwXYay.js';
 import './errors-QHD5Tlok.js';
 import './types-75UokagF.js';

package/dist/client.js

@@ -70,9 +70,79 @@ function fromConvexError(error) {
 // src/core/accounts.ts
 function createAccountsClient(config = {}) {
   return {
-    retrieve: async () => stub("accounts.retrieve"),
+    retrieve: async (accountId) => {
+      if (!config.data) {
+        return stub("accounts.retrieve");
+      }
+      try {
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (account.id !== accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.retrieve currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: accountId,
+                authenticatedAccountId: account.id
+              }
+            }),
+            null
+          ];
+        }
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     lookup: async () => stub("accounts.lookup"),
-    update: async () => stub("accounts.update"),
+    update: async (input) => {
+      if (!config.data) {
+        return stub("accounts.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "accounts.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        const current = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (current.id !== input.accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.update currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: input.accountId,
+                authenticatedAccountId: current.id
+              }
+            }),
+            null
+          ];
+        }
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const updated = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, updated];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     provisionPersonal: async (input) => {
       if (!config.data) {
         return stub(
@@ -695,7 +765,34 @@ function createMeClient(config = {}) {
         return [fromConvexError(cause), null];
       }
     },
-    update: async () => stub("me.update")
+    update: async (input) => {
+      if (!config.data) {
+        return stub("me.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "me.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
   };
 }
 
@@ -1504,6 +1601,96 @@ function createSubAccountsClient() {
   };
 }
 
+// src/core/token-transfers.ts
+var toTokenTransferId = (raw) => {
+  if (typeof raw !== "string" || raw.length === 0) {
+    throw new Error(
+      `Invalid tokenTransferId: expected non-empty string, got ${String(raw)}`
+    );
+  }
+  return raw;
+};
+function brandRow(row) {
+  return {
+    ...row,
+    id: toTokenTransferId(row.id)
+  };
+}
+function createTokenTransfersClient(config = {}) {
+  return {
+    list: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.list");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.list,
+          {
+            limit: input?.limit,
+            cursor: input?.cursor,
+            direction: input?.direction
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_AUTHENTICATED",
+              message: "tokenTransfers.list requires an authenticated session."
+            }),
+            null
+          ];
+        }
+        return [
+          null,
+          {
+            object: "list",
+            data: raw.items.map(brandRow),
+            page: {
+              hasMore: raw.hasMore,
+              nextCursor: raw.nextCursor
+            },
+            displayCurrency: raw.displayCurrency
+          }
+        ];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
+    retrieve: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.retrieve");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.getByTxLogIndex,
+          {
+            txHash: input.txHash,
+            logIndex: input.logIndex,
+            chainId: input.chainId
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_FOUND",
+              message: `tokenTransfer (txHash=${input.txHash}, logIndex=${input.logIndex}) not found or not visible to caller.`,
+              details: {
+                txHash: input.txHash,
+                logIndex: input.logIndex,
+                chainId: input.chainId
+              }
+            }),
+            null
+          ];
+        }
+        return [null, brandRow(raw)];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
+  };
+}
+
 // src/core/virtual-accounts.ts
 function createVirtualAccountsClient() {
   return {
@@ -2247,6 +2434,7 @@ function createCapxulClient(config = {}) {
     organizations: createOrganizationsClient(config),
     payments: createPaymentsClient(config),
     transfers: createTransfersClient(),
+    tokenTransfers: createTokenTransfersClient(config),
     withdrawals: createWithdrawalsClient(config),
     documents: createDocumentsClient(),
     subAccounts: createSubAccountsClient(),

package/dist/index.cjs

@@ -73,9 +73,79 @@ function fromConvexError(error) {
 // src/core/accounts.ts
 function createAccountsClient(config = {}) {
   return {
-    retrieve: async () => stub("accounts.retrieve"),
+    retrieve: async (accountId) => {
+      if (!config.data) {
+        return stub("accounts.retrieve");
+      }
+      try {
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (account.id !== accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.retrieve currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: accountId,
+                authenticatedAccountId: account.id
+              }
+            }),
+            null
+          ];
+        }
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     lookup: async () => stub("accounts.lookup"),
-    update: async () => stub("accounts.update"),
+    update: async (input) => {
+      if (!config.data) {
+        return stub("accounts.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "accounts.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        const current = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        if (current.id !== input.accountId) {
+          return [
+            new CapxulError({
+              code: "PERMISSION_DENIED",
+              message: "accounts.update currently supports the authenticated caller's own account only.",
+              details: {
+                requestedAccountId: input.accountId,
+                authenticatedAccountId: current.id
+              }
+            }),
+            null
+          ];
+        }
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const updated = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, updated];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
     provisionPersonal: async (input) => {
       if (!config.data) {
         return stub(
@@ -699,7 +769,34 @@ function createMeClient(config = {}) {
         return [fromConvexError(cause), null];
       }
     },
-    update: async () => stub("me.update")
+    update: async (input) => {
+      if (!config.data) {
+        return stub("me.update");
+      }
+      if (input.countryCode !== void 0) {
+        return [
+          new CapxulError({
+            code: "INVALID_INPUT",
+            message: "me.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
+            details: { field: "countryCode" }
+          }),
+          null
+        ];
+      }
+      try {
+        await config.data.mutation(api.openfort.mutations.updateProfile, {
+          displayName: input.name,
+          username: input.username
+        });
+        const account = await config.data.query(
+          api.openfort.queries.getMyAccount,
+          {}
+        );
+        return [null, account];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
   };
 }
 
@@ -1508,6 +1605,96 @@ function createSubAccountsClient() {
   };
 }
 
+// src/core/token-transfers.ts
+var toTokenTransferId = (raw) => {
+  if (typeof raw !== "string" || raw.length === 0) {
+    throw new Error(
+      `Invalid tokenTransferId: expected non-empty string, got ${String(raw)}`
+    );
+  }
+  return raw;
+};
+function brandRow(row) {
+  return {
+    ...row,
+    id: toTokenTransferId(row.id)
+  };
+}
+function createTokenTransfersClient(config = {}) {
+  return {
+    list: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.list");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.list,
+          {
+            limit: input?.limit,
+            cursor: input?.cursor,
+            direction: input?.direction
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_AUTHENTICATED",
+              message: "tokenTransfers.list requires an authenticated session."
+            }),
+            null
+          ];
+        }
+        return [
+          null,
+          {
+            object: "list",
+            data: raw.items.map(brandRow),
+            page: {
+              hasMore: raw.hasMore,
+              nextCursor: raw.nextCursor
+            },
+            displayCurrency: raw.displayCurrency
+          }
+        ];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    },
+    retrieve: async (input) => {
+      if (!config.data) {
+        return stub("tokenTransfers.retrieve");
+      }
+      try {
+        const raw = await config.data.query(
+          api.tokenTransfers.queries.getByTxLogIndex,
+          {
+            txHash: input.txHash,
+            logIndex: input.logIndex,
+            chainId: input.chainId
+          }
+        );
+        if (!raw) {
+          return [
+            new CapxulError({
+              code: "NOT_FOUND",
+              message: `tokenTransfer (txHash=${input.txHash}, logIndex=${input.logIndex}) not found or not visible to caller.`,
+              details: {
+                txHash: input.txHash,
+                logIndex: input.logIndex,
+                chainId: input.chainId
+              }
+            }),
+            null
+          ];
+        }
+        return [null, brandRow(raw)];
+      } catch (cause) {
+        return [fromConvexError(cause), null];
+      }
+    }
+  };
+}
+
 // src/core/virtual-accounts.ts
 function createVirtualAccountsClient() {
   return {
@@ -1530,6 +1717,15 @@ function createVirtualCardsClient() {
   };
 }
 
+// ../observability/src/try-catch.ts
+async function tryCatch(promise) {
+  try {
+    return [null, await promise];
+  } catch (e) {
+    return [e instanceof Error ? e : new Error(String(e)), null];
+  }
+}
+
 // ../observability/src/debug-log.ts
 function isDevelopmentBuild() {
   if (typeof process === "undefined") {
@@ -2350,6 +2546,7 @@ function createCapxulClient(config = {}) {
     organizations: createOrganizationsClient(config),
     payments: createPaymentsClient(config),
     transfers: createTransfersClient(),
+    tokenTransfers: createTokenTransfersClient(config),
     withdrawals: createWithdrawalsClient(config),
     documents: createDocumentsClient(),
     subAccounts: createSubAccountsClient(),
@@ -2493,6 +2690,7 @@ exports.toPaymentId = toPaymentId;
 exports.toPhoneNumber = toPhoneNumber;
 exports.toSafeId = toSafeId;
 exports.toSubAccountId = toSubAccountId;
+exports.toTokenTransferId = toTokenTransferId;
 exports.toTransferId = toTransferId;
 exports.toTreasuryId = toTreasuryId;
 exports.toUsername = toUsername;
@@ -2501,4 +2699,5 @@ exports.toVirtualCardId = toVirtualCardId;
 exports.toWebhookEndpointId = toWebhookEndpointId;
 exports.toWebhookEventId = toWebhookEventId;
 exports.toWithdrawalId = toWithdrawalId;
+exports.tryCatch = tryCatch;
 exports.verifyWebhook = verifyWebhook;