@capxul/sdk 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/index.mjs

@@ -1600,7 +1600,7 @@ async function recoverRawDigestSigner(input) {
 }
 //#endregion
 //#region package.json
-var version = "1.0.0-alpha.11";
+var version = "1.0.0-alpha.13";
 //#endregion
 //#region src/ports/auth-client.ts
 var AuthClientError = class extends Data.TaggedError("AuthClientError") {};
@@ -5909,7 +5909,77 @@ function makeAccountsMethods(deps) {
 	};
 }
 //#endregion
+//#region src/client/current-user.ts
+function makeCurrentUserMethods(deps) {
+	return { async get(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "currentUser.get" })
+		};
+		const user = await deps.me.get(options);
+		if (!user.ok) return {
+			ok: false,
+			error: user.error
+		};
+		const [account, smartAccount, organizations] = await Promise.all([
+			deps.accounts.read(options),
+			deps.smartAccount.loadCurrent(options),
+			deps.orgs(options)
+		]);
+		if (!account.ok) return {
+			ok: false,
+			error: account.error
+		};
+		if (!smartAccount.ok) return {
+			ok: false,
+			error: smartAccount.error
+		};
+		if (!organizations.ok) return {
+			ok: false,
+			error: organizations.error
+		};
+		return {
+			ok: true,
+			value: {
+				user: {
+					id: user.value.authUserId,
+					email: user.value.email,
+					displayName: user.value.displayName,
+					handle: null,
+					paymentLink: null
+				},
+				personalAccount: {
+					id: account.value.id,
+					address: smartAccount.value?.smartAccountAddress ?? null
+				},
+				organizations: organizations.value.map((organization) => ({
+					id: organization.id,
+					name: organization.name,
+					handle: organization.handle,
+					role: organization.role,
+					account: {
+						id: organization.treasury.id,
+						address: organization.safeAddress
+					}
+				}))
+			}
+		};
+	} };
+}
+//#endregion
 //#region src/client/financial-ops.ts
+function actorReferenceToBackend(actor) {
+	if (actor === void 0) return void 0;
+	switch (actor.kind) {
+		case "personal": return { kind: "account" };
+		case "organization": return {
+			kind: "org",
+			orgId: actor.organizationId
+		};
+		case "account":
+		case "org": return actor;
+	}
+}
 const DEFAULT_FUNCTIONS = {
 	me: makeFunctionReference("financialOps/queries:me"),
 	depositInstructions: makeFunctionReference("financialOps/queries:depositInstructions"),
@@ -5969,40 +6039,88 @@ function makeFinancialOpsMethods(deps) {
 			get: (payeeId, options) => runIfActive(options?.signal, "payees.get", () => deps.convexCall.query(fns.getPayee, { payeeId })),
 			resolve: (recipient, options) => runIfActive(options?.signal, "payees.resolve", () => deps.convexCall.query(fns.resolvePayee, { recipient }))
 		},
+		targets: { resolve: async (reference, options) => {
+			switch (reference.kind) {
+				case "handle": return mapOk$1(await runIfActive(options?.signal, "targets.resolve.handle", () => deps.convexCall.query(fns.resolveHandle, { handle: reference.handle })), (target) => resolvedTargetFromResolution(reference, target));
+				case "email": return mapOk$1(await runIfActive(options?.signal, "targets.resolve.email", () => deps.convexCall.query(fns.resolvePayee, { recipient: reference.email })), (target) => resolvedTargetFromResolution(reference, target));
+				case "organization": {
+					const resolved = await runIfActive(options?.signal, "targets.resolve.organization", () => deps.convexCall.query(fns.resolveHandle, { handle: reference.handle }));
+					if (!resolved.ok) return {
+						ok: false,
+						error: resolved.error
+					};
+					if (resolved.value.kind !== "org") return {
+						ok: false,
+						error: Errors.invalidInput("reference", "organization handle could not be resolved")
+					};
+					return {
+						ok: true,
+						value: resolvedTargetFromResolution(reference, resolved.value)
+					};
+				}
+				case "payee": {
+					const payee = await runIfActive(options?.signal, "targets.resolve.payee", () => deps.convexCall.query(fns.getPayee, { payeeId: reference.id }));
+					if (!payee.ok) return {
+						ok: false,
+						error: payee.error
+					};
+					if (payee.value === null) return {
+						ok: false,
+						error: Errors.invalidInput("reference", "payee not found")
+					};
+					return {
+						ok: true,
+						value: resolvedTargetFromPayee(reference, payee.value)
+					};
+				}
+				case "destination": return Promise.resolve({
+					ok: false,
+					error: Errors.notImplemented("targets", "resolve.destination")
+				});
+			}
+		} },
 		destinations: {
 			add: async (input, options) => {
-				const ref = normalizeRefForBackend(input.ref, "ref");
+				const ref = normalizeDestinationInputRef(input, "target");
 				if (!ref.ok) return {
 					ok: false,
 					error: ref.error
 				};
-				return runIfActive(options?.signal, "destinations.add", () => deps.convexCall.mutation(fns.addDestination, {
-					...input.actor === void 0 ? {} : { actor: input.actor },
+				if (ref.value === void 0) return {
+					ok: false,
+					error: Errors.invalidInput("target", "required for destinations.add")
+				};
+				return mapOk$1(await runIfActive(options?.signal, "destinations.add", () => deps.convexCall.mutation(fns.addDestination, {
+					...input.actor === void 0 ? {} : { actor: actorReferenceToBackend(input.actor) },
 					ref: ref.value,
-					kind: input.kind,
+					kind: destinationKindToBackend(input.kind),
 					...input.label === void 0 ? {} : { label: input.label },
 					payload: input.payload
-				}));
+				})), destinationFromBackend);
 			},
 			list: async (input, options) => {
-				const ref = normalizeRefForBackend(input.ref, "ref");
+				const ref = normalizeDestinationInputRef(input, "target");
 				if (!ref.ok) return {
 					ok: false,
 					error: ref.error
 				};
-				return runIfActive(options?.signal, "destinations.list", () => deps.convexCall.query(fns.listDestinations, {
-					...input.actor === void 0 ? {} : { actor: input.actor },
-					ref: ref.value
-				}));
+				return mapOk$1(await runIfActive(options?.signal, "destinations.list", () => deps.convexCall.query(fns.listDestinations, {
+					...input.actor === void 0 ? {} : { actor: actorReferenceToBackend(input.actor) },
+					...ref.value === void 0 ? {} : { ref: ref.value }
+				})), (destinations) => destinations.map(destinationFromBackend).filter((destination) => input.kind === void 0 || destination.kind === input.kind));
 			},
 			remove: (input, options) => runIfActive(options?.signal, "destinations.remove", () => deps.convexCall.mutation(fns.removeDestination, {
-				...input.actor === void 0 ? {} : { actor: input.actor },
+				...input.actor === void 0 ? {} : { actor: actorReferenceToBackend(input.actor) },
 				destinationId: input.destinationId
 			}))
 		},
 		payments: {
 			pay: async (input, options) => {
-				const to = normalizeRefForBackend(input.to, "to");
+				if (actorReferenceToBackend(input.actor)?.kind === "org") return {
+					ok: false,
+					error: Errors.notImplemented("payments", "pay.organizationActor")
+				};
+				const to = normalizeTargetForBackend(input.to, "to");
 				if (!to.ok) return {
 					ok: false,
 					error: to.error
@@ -6010,13 +6128,14 @@ function makeFinancialOpsMethods(deps) {
 				return mapOk$1(await runIfActive(options?.signal, "payments.pay", () => deps.convexCall.mutation(fns.pay, {
 					to: to.value,
 					amount: input.amount,
+					...input.paymentType === void 0 ? {} : { paymentType: input.paymentType },
 					...input.document === void 0 ? {} : { document: input.document },
 					...input.timing === void 0 ? {} : { timing: input.timing },
 					...input.lineItems === void 0 ? {} : { lineItems: input.lineItems }
 				})), normalizePaymentTiming$1);
 			},
 			payout: async (input, options) => mapOk$1(await runIfActive(options?.signal, "payments.payout", () => deps.convexCall.mutation(fns.payout, {
-				...input.actor === void 0 ? {} : { actor: input.actor },
+				...input.actor === void 0 ? {} : { actor: actorReferenceToBackend(input.actor) },
 				destinationId: input.destinationId,
 				amount: input.amount
 			})), normalizePaymentTiming$1),
@@ -6027,6 +6146,16 @@ function makeFinancialOpsMethods(deps) {
 			})),
 			list: async (options) => mapOk$1(await runIfActive(options?.signal, "payments.list", () => deps.convexCall.query(fns.listPayments, {})), (payments) => payments.map(normalizePaymentTiming$1)),
 			get: async (paymentId, options) => mapOk$1(await runIfActive(options?.signal, "payments.get", () => deps.convexCall.query(fns.getPayment, { paymentId })), (payment) => payment === null ? null : normalizePaymentTiming$1(payment)),
+			cancel: (paymentId, options) => {
+				if (options?.signal?.aborted) return Promise.resolve({
+					ok: false,
+					error: Errors.cancelled({ operation: "payments.cancel" })
+				});
+				return Promise.resolve({
+					ok: false,
+					error: Errors.notImplemented("payments", "cancel")
+				});
+			},
 			_internal: {
 				markSettled: (input, options) => runIfActive(options?.signal, "payments.markSettled", () => deps.convexCall.action(fns.markPaymentSettled, {
 					paymentId: input.paymentId,
@@ -6087,6 +6216,38 @@ function makeFinancialOpsMethods(deps) {
 				commitmentRef: (paymentId, options) => runIfActive(options?.signal, "payments.commitmentRef", () => deps.convexCall.query(fns.getCommitmentRef, { paymentId }))
 			}
 		},
+		activity: { list: (params, options) => {
+			if (options?.signal?.aborted) return Promise.resolve({
+				ok: false,
+				error: Errors.cancelled({ operation: "activity.list" })
+			});
+			return Promise.resolve({
+				ok: false,
+				error: Errors.notImplemented("activity", "list")
+			});
+		} },
+		offramp: {
+			quote: (input, options) => {
+				if (options?.signal?.aborted) return Promise.resolve({
+					ok: false,
+					error: Errors.cancelled({ operation: "offramp.quote" })
+				});
+				return Promise.resolve({
+					ok: false,
+					error: Errors.notImplemented("offramp", "quote")
+				});
+			},
+			status: (offrampId, options) => {
+				if (options?.signal?.aborted) return Promise.resolve({
+					ok: false,
+					error: Errors.cancelled({ operation: "offramp.status" })
+				});
+				return Promise.resolve({
+					ok: false,
+					error: Errors.notImplemented("offramp", "status")
+				});
+			}
+		},
 		paymentDocuments: {
 			verify: (documentHash, options) => runIfActive(options?.signal, "paymentDocuments.verify", () => deps.convexCall.query(fns.verifyPaymentDocument, { documentHash })),
 			render: (documentHash, options) => runIfActive(options?.signal, "paymentDocuments.render", () => deps.convexCall.query(fns.renderStoredDocument, { documentHash }))
@@ -6166,6 +6327,169 @@ function handleRefValue(value, field) {
 	const trimmed = nonEmptyRefValue(value, field);
 	return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
 }
+function refFromTargetReference(reference, field) {
+	try {
+		if (typeof reference === "string") throw Errors.invalidInput(field, "target must be a typed TargetReference variant");
+		if (typeof reference !== "object" || reference === null || !("kind" in reference)) throw Errors.invalidInput(field, "target must be a typed TargetReference variant");
+		switch (reference.kind) {
+			case "handle": return {
+				ok: true,
+				value: {
+					kind: "handle",
+					handle: reference.handle
+				}
+			};
+			case "email": return {
+				ok: true,
+				value: {
+					kind: "email",
+					email: reference.email
+				}
+			};
+			case "organization": return {
+				ok: true,
+				value: {
+					kind: "orgHandle",
+					orgHandle: reference.handle
+				}
+			};
+			case "payee": return {
+				ok: true,
+				value: {
+					kind: "payeeId",
+					payeeId: reference.id
+				}
+			};
+			case "destination": return {
+				ok: false,
+				error: Errors.notImplemented("targets", "reference.destination")
+			};
+			default: throw Errors.invalidInput(field, "target must be a known TargetReference variant");
+		}
+	} catch (cause) {
+		if (cause instanceof Error && "code" in cause) return {
+			ok: false,
+			error: cause
+		};
+		return {
+			ok: false,
+			error: Errors.invalidInput(field, "target must be a typed TargetReference variant")
+		};
+	}
+}
+function normalizeTargetForBackend(reference, field) {
+	const ref = refFromTargetReference(reference, field);
+	return ref.ok ? normalizeRefForBackend(ref.value, field) : ref;
+}
+function normalizeDestinationInputRef(input, field) {
+	if (input.target !== void 0) return normalizeTargetForBackend(input.target, field);
+	if (input.ref !== void 0) return normalizeDestinationRefForBackend(input.ref, "ref");
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+function targetReferenceFromBackendRef(ref) {
+	switch (ref.kind) {
+		case "handle": return {
+			kind: "handle",
+			handle: ref.handle
+		};
+		case "email": return {
+			kind: "email",
+			email: ref.email
+		};
+		case "orgHandle": return {
+			kind: "organization",
+			handle: ref.orgHandle
+		};
+		case "payeeId": return {
+			kind: "payee",
+			id: ref.payeeId
+		};
+		case "capxulUserId": throw Errors.notImplemented("targets", "reference.capxulUserId");
+	}
+}
+function resolvedTargetFromResolution(reference, resolution) {
+	const kind = resolution.kind === "org" ? "organization" : resolution.kind === "payee" ? "payee" : "person";
+	return {
+		reference,
+		label: resolution.label,
+		kind,
+		capabilities: {
+			canPay: true,
+			canRequest: true,
+			canPayout: false
+		}
+	};
+}
+function resolvedTargetFromPayee(reference, payee) {
+	return {
+		reference,
+		label: payee.label,
+		kind: "payee",
+		capabilities: {
+			canPay: true,
+			canRequest: true,
+			canPayout: false
+		}
+	};
+}
+function destinationKindToBackend(kind) {
+	switch (kind) {
+		case "bank_account": return "bank";
+		case "mobile_money": return "mobile-money";
+		case "external_account": return "wallet";
+	}
+}
+function destinationKindFromBackend(kind) {
+	switch (kind) {
+		case "bank": return "bank_account";
+		case "mobile-money": return "mobile_money";
+		case "wallet": return "external_account";
+	}
+}
+function destinationRailFromBackend(destination) {
+	switch (destination.kind) {
+		case "bank": {
+			const payload = destination.payload;
+			return {
+				kind: "bank",
+				country: payload.country,
+				currency: payload.currency
+			};
+		}
+		case "mobile-money": {
+			const payload = destination.payload;
+			return {
+				kind: "mobile_money",
+				country: payload.country,
+				currency: payload.currency,
+				provider: payload.provider
+			};
+		}
+		case "wallet": return {
+			kind: "chain",
+			network: destination.payload.network,
+			asset: "USD"
+		};
+	}
+}
+function destinationFromBackend(destination) {
+	return {
+		...destination,
+		target: targetReferenceFromBackendRef(destination.ref),
+		kind: destinationKindFromBackend(destination.kind),
+		rail: destinationRailFromBackend(destination)
+	};
+}
+function normalizeDestinationRefForBackend(ref, field) {
+	if (typeof ref === "object" && ref !== null && "kind" in ref && ref.kind === "capxulUserId") return {
+		ok: false,
+		error: Errors.notImplemented("targets", "reference.capxulUserId")
+	};
+	return normalizeRefForBackend(ref, field);
+}
 function normalizeRefForBackend(ref, field) {
 	try {
 		if (typeof ref === "string") throw Errors.invalidInput(field, "recipient must be a typed Ref variant");
@@ -6228,10 +6552,18 @@ function normalizePaymentTiming$1(payment) {
 }
 function mapOk$1(result, f) {
 	if (!result.ok) return result;
-	return {
-		ok: true,
-		value: f(result.value)
-	};
+	try {
+		return {
+			ok: true,
+			value: f(result.value)
+		};
+	} catch (cause) {
+		if (cause instanceof Error && "code" in cause) return {
+			ok: false,
+			error: cause
+		};
+		throw cause;
+	}
 }
 async function runIfActive(signal, operation, effect) {
 	if (signal?.aborted === true) return {
@@ -6753,30 +7085,6 @@ function inviteMemberProgram(orgId, input) {
 		return member;
 	});
 }
-function pendingMembersProgram(orgId) {
-	return Effect.gen(function* () {
-		const deps = yield* OrgDepsTag;
-		if (deps.orgPort?.pendingMembers !== void 0) return yield* deps.orgPort.pendingMembers({ orgId }).pipe(Effect.mapError((error) => error.publicError));
-		if (deps.orgPort !== void 0) return (yield* deps.orgPort.listMembers({ orgId }).pipe(Effect.mapError((error) => error.publicError))).filter((member) => member.status === "pending" || member.status === "pending_safe" || member.status === "pending_grant");
-		return [];
-	});
-}
-function resendInviteTokenProgram(orgId, email) {
-	return Effect.gen(function* () {
-		const deps = yield* OrgDepsTag;
-		if (deps.orgPort?.resendInviteToken !== void 0) return yield* deps.orgPort.resendInviteToken({
-			orgId,
-			email
-		}).pipe(Effect.mapError((error) => error.publicError));
-		if (!isHermeticOrgDeps(deps)) return yield* Effect.fail(missingLiveOrgDep("orgPort.resendInviteToken"));
-		return hermeticMember({
-			orgId,
-			email,
-			role: "Member",
-			status: "pending"
-		});
-	});
-}
 function detectAndAcceptPendingInvitationsProgram() {
 	return Effect.gen(function* () {
 		const deps = yield* OrgDepsTag;
@@ -7045,6 +7353,32 @@ function makeOrgMethods(deps) {
 					});
 					return toCapxulResult(readTreasuryProgram(orgId), layer);
 				},
+				account: { async get(options) {
+					if (options?.signal?.aborted) return {
+						ok: false,
+						error: Errors.cancelled({ operation: "org.account.get" })
+					};
+					const treasury = await toCapxulResult(readTreasuryProgram(orgId), layer);
+					if (!treasury.ok) return {
+						ok: false,
+						error: treasury.error
+					};
+					const orgs = await toCapxulResult(listOrgsProgram(), layer);
+					if (!orgs.ok) return {
+						ok: false,
+						error: orgs.error
+					};
+					const org = orgs.value.find((candidate) => candidate.id === orgId);
+					return {
+						ok: true,
+						value: {
+							id: treasury.value.id,
+							address: org?.safeAddress ?? null,
+							balance: treasury.value.balance,
+							available: treasury.value.available
+						}
+					};
+				} },
 				members(_options) {
 					if (_options?.signal?.aborted) return Promise.resolve({
 						ok: false,
@@ -7073,20 +7407,6 @@ function makeOrgMethods(deps) {
 					});
 					return toCapxulResult(inviteMemberProgram(orgId, _input), layer);
 				},
-				pendingMembers(_options) {
-					if (_options?.signal?.aborted) return Promise.resolve({
-						ok: false,
-						error: Errors.cancelled({ operation: "org.pendingMembers" })
-					});
-					return toCapxulResult(pendingMembersProgram(orgId), layer);
-				},
-				inviteToken: { resend(_input, _options) {
-					if (_options?.signal?.aborted) return Promise.resolve({
-						ok: false,
-						error: Errors.cancelled({ operation: "org.inviteToken.resend" })
-					});
-					return toCapxulResult(resendInviteTokenProgram(orgId, String(_input.email)), layer);
-				} },
 				removeMember(_input, _options) {
 					if (_options?.signal?.aborted) return Promise.resolve({
 						ok: false,
@@ -7115,6 +7435,16 @@ function makeOrgMethods(deps) {
 					});
 					return toCapxulResult(batchPayrollProgram(orgId, _input), layer);
 				},
+				auditLog(_options) {
+					if (_options?.signal?.aborted) return Promise.resolve({
+						ok: false,
+						error: Errors.cancelled({ operation: "org.auditLog" })
+					});
+					return Promise.resolve({
+						ok: false,
+						error: Errors.notImplemented("organizationAuditLog", "list")
+					});
+				},
 				payroll: convexCall === void 0 ? makeNotImplementedPayrollMethods() : makePayrollMethods({
 					orgId: String(orgId),
 					convexCall
@@ -7469,6 +7799,12 @@ function assembleCapxulClient(input) {
 	if (selectedOrgPort !== void 0) detectPendingOrgInvitations = async () => {
 		await orgMethods.orgs.detectAndAcceptPendingInvitations();
 	};
+	const currentUser = makeCurrentUserMethods({
+		me: financialOps.me,
+		accounts,
+		smartAccount,
+		orgs: orgMethods.orgs
+	});
 	const onboarding = makeOnboardingMethods({
 		currentSession: async () => {
 			const session = await currentSession(actor, authCache);
@@ -7489,11 +7825,15 @@ function assembleCapxulClient(input) {
 		identity,
 		account,
 		accounts,
+		currentUser,
 		me: financialOps.me,
 		handles: financialOps.handles,
 		payees: financialOps.payees,
+		targets: financialOps.targets,
 		destinations: financialOps.destinations,
 		payments: financialOps.payments,
+		activity: financialOps.activity,
+		offramp: financialOps.offramp,
 		paymentDocuments: financialOps.paymentDocuments,
 		paymentRequests: financialOps.paymentRequests,
 		workbench: financialOps.workbench,
@@ -7969,6 +8309,6 @@ async function createCapxulClient(input) {
 	return createCapxulClient$1(input);
 }
 //#endregion
-export { captureException, captureExceptionSync, createCapxulClient, deriveDevPrivateKey, devPrivateKeySigner, eip1193AccountProvider, embeddedSigner, injectedWalletSigner, isSettingUpLifecycle, localPrivateKeyAccountProvider, openfortEmbeddedSigner, openfortEmbeddedSignerFromWallet, openfortEmbeddedWalletPort };
+export { CapxulError, captureException, captureExceptionSync, createCapxulClient, deriveDevPrivateKey, devPrivateKeySigner, eip1193AccountProvider, embeddedSigner, injectedWalletSigner, isCapxulError, isSettingUpLifecycle, localPrivateKeyAccountProvider, openfortEmbeddedSigner, openfortEmbeddedSignerFromWallet, openfortEmbeddedWalletPort };
 
 //# sourceMappingURL=index.mjs.map