@degenerate/generic 0.2.7 → 0.4.0

package/dist/models/shareblock/shareblock-models.js

@@ -0,0 +1,395 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IShareBlockMarkDefaultedInputSchema = exports.IShareBlockMarkFullyRepaidInputSchema = exports.IShareBlockRecordRepaymentInputSchema = exports.IShareBlockSnapshotForRepaymentInputSchema = exports.IShareBlockSetLenderGraceDecisionInputSchema = exports.IShareBlockMarkFullyDistributedInputSchema = exports.IShareBlockDisburseInputSchema = exports.IShareBlockFundInputSchema = exports.IShareBlockRegisterLenderInputSchema = exports.IShareBlockCommitInputSchema = exports.IShareBlockCloseInputSchema = exports.IShareBlockWithdrawInputSchema = exports.IShareBlockDepositInputSchema = exports.IShareBlockInitialStateInputSchema = exports.IShareBlockMetadataSchema = exports.IGraceRepaymentShareBlockStateSchema = exports.IGraceRepaymentParticipantSchema = exports.IDistributionShareBlockStateSchema = exports.IFundingShareBlockStateSchema = exports.IShareBlockStateSchema = exports.IShareBlockParticipantSchema = exports.ShareBlockParticipantRoleSchema = exports.ShareBlockParticipantRole = exports.ShareBlockTypeSchema = exports.ShareBlockType = void 0;
+const zod_1 = __importDefault(require("zod"));
+//#region Enums
+/**
+ * The four ShareBlock specializations the platform uses to move money
+ * through a loan's lifecycle.
+ *
+ *   - `Clearing`       — neutral holding spot funds pass through before they're
+ *                        committed to either side of a deal. Used to net
+ *                        borrower and lender flows before settling.
+ *   - `Funding`        — the lender-funded pool that backs a specific loan.
+ *                        Holds principal between funding and disbursement.
+ *   - `Distribution`   — the destination ShareBlock that pays principal to a
+ *                        borrower or returns/interest to a lender.
+ *   - `GraceRepayment` — the borrower-repayment block for Rapture's Grace
+ *                        product. Per-lender Grace-or-yield decisions are
+ *                        toggled while the loan is in flight, snapshotted at
+ *                        repayment-initiate, and drive the blended-rate
+ *                        allocation when the borrower pays. Terminal state is
+ *                        either `fullyRepaid: true` OR `defaulted: true`,
+ *                        mutually exclusive.
+ *
+ * New ShareBlock variants should be additive — never re-use a value with new
+ * semantics, since downstream rule libraries pattern-match on the literal.
+ */
+var ShareBlockType;
+(function (ShareBlockType) {
+    ShareBlockType["Clearing"] = "Clearing";
+    ShareBlockType["Funding"] = "Funding";
+    ShareBlockType["Distribution"] = "Distribution";
+    ShareBlockType["GraceRepayment"] = "GraceRepayment";
+})(ShareBlockType || (exports.ShareBlockType = ShareBlockType = {}));
+exports.ShareBlockTypeSchema = zod_1.default.enum([
+    'Clearing',
+    'Funding',
+    'Distribution',
+    'GraceRepayment',
+]);
+//#endregion Enums
+//#region Participant
+/**
+ * Roles a participant plays inside a ShareBlock. A single party may hold
+ * multiple roles across different ShareBlocks (e.g. the same uid is `Lender`
+ * on a Funding block and `Recipient` on a Distribution block).
+ */
+var ShareBlockParticipantRole;
+(function (ShareBlockParticipantRole) {
+    ShareBlockParticipantRole["Borrower"] = "Borrower";
+    ShareBlockParticipantRole["Lender"] = "Lender";
+    ShareBlockParticipantRole["Platform"] = "Platform";
+    ShareBlockParticipantRole["Recipient"] = "Recipient";
+})(ShareBlockParticipantRole || (exports.ShareBlockParticipantRole = ShareBlockParticipantRole = {}));
+exports.ShareBlockParticipantRoleSchema = zod_1.default.enum([
+    'Borrower',
+    'Lender',
+    'Platform',
+    'Recipient',
+]);
+/**
+ * A party in a ShareBlock with their associated role and committed amount.
+ * `committedAmount` is the headline contribution promised by the participant;
+ * `settledAmount` tracks how much has actually moved (so partial fills are
+ * representable). Both are in the ShareBlock's `currency`.
+ */
+exports.IShareBlockParticipantSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    role: exports.ShareBlockParticipantRoleSchema,
+    committedAmount: zod_1.default.number().nonnegative(),
+    settledAmount: zod_1.default.number().nonnegative(),
+});
+//#endregion Participant
+//#region State
+/**
+ * The mutable state carried inside a ShareBlock's `_currentState`. This is
+ * the canonical shape rules and functions inspect when proposing changes.
+ *
+ *   - `balance` — funds currently held in the ShareBlock. Never negative.
+ *   - `currency` — ISO-4217 code (e.g. `'USD'`, `'CAD'`). Pinned at creation.
+ *   - `isOpen` — whether the ShareBlock will accept further transactions.
+ *                Closing is irreversible; once `false`, all standard rules
+ *                reject mutating proposals.
+ *   - `participants` — committed parties keyed by `userId`. Adding a
+ *                participant goes through a rule-gated function so the
+ *                participant list itself is auditable.
+ */
+exports.IShareBlockStateSchema = zod_1.default.object({
+    blockType: exports.ShareBlockTypeSchema,
+    balance: zod_1.default.number().nonnegative(),
+    currency: zod_1.default.string().min(3).max(3),
+    isOpen: zod_1.default.boolean(),
+    participants: zod_1.default.record(zod_1.default.string(), exports.IShareBlockParticipantSchema),
+});
+/**
+ * Funding-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `committed` — once `true`, the block's funds are locked: deposits and
+ *                   withdrawals become no-ops, and a "committed-is-monotonic"
+ *                   rule blocks any proposal that flips it back to `false`.
+ *   - `committedBy` / `committedAt` — audit attribution for the commit moment.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+exports.IFundingShareBlockStateSchema = exports.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(exports.ShareBlockTypeSchema.enum.Funding),
+    committed: zod_1.default.boolean(),
+    committedBy: zod_1.default.string().optional(),
+    committedAt: zod_1.default.number().optional(),
+});
+/**
+ * Distribution-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `distributed` — once `true`, the block is fully paid out and further
+ *                     disbursements become no-ops. Enforced as monotonic by
+ *                     a dedicated rule (mirrors Funding's `committed`).
+ *   - `distributedAt` — audit attribution for the moment the block was
+ *                       marked fully distributed.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+exports.IDistributionShareBlockStateSchema = exports.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(exports.ShareBlockTypeSchema.enum.Distribution),
+    distributed: zod_1.default.boolean(),
+    distributedBy: zod_1.default.string().optional(),
+    distributedAt: zod_1.default.number().optional(),
+});
+/**
+ * GraceRepayment-specific participant. Extends the base participant with
+ * three Grace-specific fields plus a denormalized ShareBlock count:
+ *
+ *   - `graceDecision`     — Lender-only field. The lender's current
+ *                            choice: take their yield, grant Grace, or
+ *                            undecided (the initial state when the
+ *                            GraceRepayment block is constructed).
+ *                            Borrower and Platform participants always
+ *                            carry `'undecided'` and never mutate it.
+ *   - `decidedAtMs`       — Unix-ms timestamp the lender last set their
+ *                            decision. `null` while undecided.
+ *   - `snapshotDecision`  — The locked-in decision at the moment the
+ *                            borrower initiated repayment. `null` until
+ *                            snapshot. After snapshot it's the
+ *                            authoritative value the per-lender
+ *                            settlement uses.
+ *   - `shareBlockCount`   — Derived count of $10 ShareBlocks held by
+ *                            this lender on this loan
+ *                            (`committedAmount / 1000` for cents-based
+ *                            committed amounts). Cached for fast UI
+ *                            queries; the canonical source is still
+ *                            `committedAmount`.
+ */
+exports.IGraceRepaymentParticipantSchema = exports.IShareBlockParticipantSchema.extend({
+    graceDecision: zod_1.default.enum(['yield', 'grace', 'undecided']),
+    /** Unset until the lender first sets a decision. */
+    decidedAtMs: zod_1.default.number().int().nonnegative().optional(),
+    /** Unset until the borrower initiates repayment. */
+    snapshotDecision: zod_1.default.enum(['yield', 'grace']).optional(),
+    shareBlockCount: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * GraceRepayment-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `outstandingPrincipalCents`  — running principal balance the
+ *                                     borrower owes. Decrements as
+ *                                     repayments land.
+ *   - `outstandingInterestCents`   — interest owed at the time of
+ *                                     repayment snapshot. Computed
+ *                                     atomically at snapshot from the
+ *                                     blended rate; decrements as
+ *                                     repayments land.
+ *   - `repaymentSnapshotAtMs`      — unix-ms timestamp the per-lender
+ *                                     Grace decisions were locked in.
+ *                                     `null` until the borrower
+ *                                     initiates repayment.
+ *   - `blendedRatePercent`         — weighted-average effective rate
+ *                                     computed at snapshot. `null` pre-
+ *                                     snapshot.
+ *   - `finalEffectiveRatePercent`  — what the borrower actually pays;
+ *                                     equal to `blendedRatePercent`
+ *                                     under the standard formula. `null`
+ *                                     pre-snapshot.
+ *   - `fullyRepaid` / `defaulted`  — mutually exclusive terminal flags.
+ *                                     Both monotonic (once true, never
+ *                                     back to false).
+ *   - `defaultReason` / `defaultedAtMs` — audit attribution for the
+ *                                          default moment.
+ *
+ * Participants are typed as `IGraceRepaymentParticipant` (extended
+ * with per-lender Grace decision fields).
+ */
+exports.IGraceRepaymentShareBlockStateSchema = exports.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(exports.ShareBlockTypeSchema.enum.GraceRepayment),
+    participants: zod_1.default.record(zod_1.default.string(), exports.IGraceRepaymentParticipantSchema),
+    outstandingPrincipalCents: zod_1.default.number().int().nonnegative(),
+    outstandingInterestCents: zod_1.default.number().int().nonnegative(),
+    /** Unset until the borrower initiates repayment. */
+    repaymentSnapshotAtMs: zod_1.default.number().int().nonnegative().optional(),
+    /** Computed at snapshot; unset pre-snapshot. */
+    blendedRatePercent: zod_1.default.number().optional(),
+    /** Computed at snapshot; unset pre-snapshot. */
+    finalEffectiveRatePercent: zod_1.default.number().optional(),
+    /**
+     * Borrower's baseline rate at snapshot. Captured so the
+     * `recordRepayment` per-lender settlement can recompute the
+     * yield-side interest allocation without rolling the inputs back
+     * in through the call (the audit chain already carries
+     * `snapshotForRepayment`'s input, but the per-lender allocation
+     * function reads from current state, not the prior transaction).
+     */
+    snapshotBaselineRatePercent: zod_1.default.number().optional(),
+    /** Grace micro-interest at snapshot (e.g., 0.77). */
+    snapshotGraceMicroInterestPercent: zod_1.default.number().optional(),
+    /** Grace per-ShareBlock fee at snapshot (cents, e.g., 1 = $0.01). */
+    snapshotGracePerShareBlockFeeCents: zod_1.default.number().int().nonnegative().optional(),
+    fullyRepaid: zod_1.default.boolean(),
+    defaulted: zod_1.default.boolean(),
+    /** Set when the block transitions to `defaulted: true`. */
+    defaultReason: zod_1.default.string().optional(),
+    defaultedAtMs: zod_1.default.number().int().nonnegative().optional(),
+});
+//#endregion State
+//#region Metadata
+/**
+ * Static information about a ShareBlock — set at construction and never
+ * mutated through transactions. Lives outside `IShareBlockState` because
+ * the rule-evaluation engine compares state shapes, and including identity
+ * metadata in that comparison would treat any new ShareBlock as a "change."
+ */
+exports.IShareBlockMetadataSchema = zod_1.default.object({
+    shareBlockId: zod_1.default.string(),
+    blockType: exports.ShareBlockTypeSchema,
+    relatedLoanApplicationId: zod_1.default.string().optional(),
+    description: zod_1.default.string().optional(),
+    createdAt: zod_1.default.number(),
+    createdBy: zod_1.default.string(),
+});
+/**
+ * Input shape every ShareBlock factory's `initialState` argument accepts.
+ * The factory layers the variant-specific defaults on top (`blockType`,
+ * `committed: false`, `distributed: false`, `isOpen: true`) — callers only
+ * supply the genuinely variant-agnostic fields.
+ *
+ * Used by the HTTP create route to validate the wire payload before
+ * dispatching to the matching factory.
+ */
+exports.IShareBlockInitialStateInputSchema = zod_1.default.object({
+    currency: zod_1.default.string().min(3).max(3),
+    participants: zod_1.default.record(zod_1.default.string(), exports.IShareBlockParticipantSchema),
+    balance: zod_1.default.number().nonnegative().optional(),
+});
+//#endregion Metadata
+//#region Transaction Function Inputs
+/**
+ * Input shapes for the standard ShareBlock mutating functions. Each function
+ * the factory wires up takes one of these and proposes a new
+ * `IShareBlockState`. Rules judge the transition; the ShareData container
+ * applies it iff every rule passes.
+ */
+exports.IShareBlockDepositInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+exports.IShareBlockWithdrawInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+exports.IShareBlockCloseInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(), // Who is closing the block — used for audit attribution.
+});
+/**
+ * Input for the Funding-specific `commit` function. Records who pulled the
+ * trigger on locking the funded amount; the function itself stamps
+ * `committedAt` from the system clock.
+ */
+exports.IShareBlockCommitInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+});
+/**
+ * Input for the Funding-specific `registerLender` function. Adds a new
+ * `Lender`-role participant to the block so they can subsequently
+ * `deposit` (deposit gates on participant.role === Lender).
+ *
+ * The caller (Rapture's authenticated endpoint) is responsible for
+ * authorizing the registration — i.e. for confirming that `userId` is the
+ * authenticated user pledging on this loan. The shareblock layer just
+ * enforces structural invariants (no duplicate userId, positive
+ * committedAmount, block must be open and not committed).
+ */
+exports.IShareBlockRegisterLenderInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    committedAmount: zod_1.default.number().positive().finite(),
+});
+/**
+ * Input for the Distribution-specific `fund` function. Distinct from
+ * `IShareBlockDepositInput` only at the type level: keeps the wire shape
+ * narrow to "money coming in from another block" semantics rather than the
+ * general-purpose deposit on Clearing.
+ */
+exports.IShareBlockFundInputSchema = zod_1.default.object({
+    fromBlockId: zod_1.default.string().optional(), // upstream block id when known
+    amount: zod_1.default.number().positive(),
+});
+/**
+ * Input for the Distribution-specific `disburse` function. `userId` must
+ * resolve to a participant with role `Recipient`, or the function no-ops.
+ */
+exports.IShareBlockDisburseInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    amount: zod_1.default.number().positive(),
+});
+/**
+ * Input for the Distribution-specific `markFullyDistributed` function.
+ * Records who declared the block fully paid out; the function stamps
+ * `distributedAt`.
+ */
+exports.IShareBlockMarkFullyDistributedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+});
+/**
+ * Input for the GraceRepayment `setLenderGraceDecision` function.
+ * Lender-callable while the block is open and pre-snapshot. The block's
+ * rules also enforce that the calling userId matches the participant
+ * being mutated (lenders can only set their own decisions, not others').
+ */
+exports.IShareBlockSetLenderGraceDecisionInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    decision: zod_1.default.enum(['yield', 'grace']),
+    decidedAtMs: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for the GraceRepayment `snapshotForRepayment` function.
+ * Platform-only. Atomic: freezes every Lender participant's
+ * `snapshotDecision` from their current `graceDecision`, computes
+ * `blendedRatePercent` and `finalEffectiveRatePercent` from the
+ * weighted decisions, sets `outstandingInterestCents` to the final
+ * computed amount, and stamps `repaymentSnapshotAtMs`.
+ *
+ * `graceMicroInterestPercent` and `gracePerShareBlockFeeCents` are the
+ * platform-fee configuration values used in the math; passing them via
+ * the input keeps the variant function pure (no implicit config
+ * lookup).
+ */
+exports.IShareBlockSnapshotForRepaymentInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    baselineRatePercent: zod_1.default.number().positive(),
+    termDays: zod_1.default.number().int().positive(),
+    graceMicroInterestPercent: zod_1.default.number().nonnegative(),
+    gracePerShareBlockFeeCents: zod_1.default.number().int().nonnegative(),
+    snapshotAtMs: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for the GraceRepayment `recordRepayment` function. Platform-only.
+ * Applies an inbound borrower payment per the snapshot decisions:
+ * yield-ShareBlock lenders receive their share of `borrowerInterest`;
+ * grace-ShareBlock lenders receive only the micro-interest minus the
+ * per-ShareBlock fee. Decrements `outstandingInterestCents` first,
+ * then `outstandingPrincipalCents`. Auto-marks `fullyRepaid` when
+ * both reach zero.
+ *
+ * `paymentAttemptId` is the idempotency key — a second call with the
+ * same id is a no-op.
+ */
+exports.IShareBlockRecordRepaymentInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    paymentAttemptId: zod_1.default.string(),
+    amountCents: zod_1.default.number().int().positive(),
+    paidAtMs: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for the GraceRepayment `markFullyRepaid` function. Platform-only.
+ * Asserts `outstandingPrincipalCents === 0 && outstandingInterestCents
+ * === 0` before flipping. Mutually exclusive with `markDefaulted`.
+ */
+exports.IShareBlockMarkFullyRepaidInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    asOf: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for the GraceRepayment `markDefaulted` function. Platform-only.
+ * Mutually exclusive with `markFullyRepaid`. Sets the terminal default
+ * flag + audit metadata; the post-default flow (lender write-off,
+ * borrower loyalty reset, identity-reveal opt-ins) happens in Rapture's
+ * trigger layer, not here.
+ */
+exports.IShareBlockMarkDefaultedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    reason: zod_1.default.string().min(1),
+    asOf: zod_1.default.number().int().nonnegative(),
+});
+//#endregion Transaction Function Inputs

package/dist/transactions/authority/create-safe-transaction-authority-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-safe-transaction-authority-data.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority-data.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gEAAgE,CAAC;AAE/G;;;;;;;;GAQG;AACH,QAAA,MAAM,kCAAkC,wBACf,mBAAmB,0BAChB,MAAM,2BACL,uBAAuB,iBACjC,mBAAmB,EAAE,KACrC,6BAOF,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}
+{"version":3,"file":"create-safe-transaction-authority-data.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority-data.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,6BAA6B,EAAE,MAAM,gEAAgE,CAAC;AAE/G;;;;;;;;GAQG;AACH,QAAA,MAAM,kCAAkC,GACpC,qBAAqB,mBAAmB,EACxC,wBAAwB,MAAM,EAC9B,yBAAyB,uBAAuB,EAChD,eAAe,mBAAmB,EAAE,KACrC,6BAOF,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}

package/dist/transactions/authority/create-safe-transaction-authority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-safe-transaction-authority.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,yBAAyB,EAE5B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACH,6BAA6B,EAC7B,yBAAyB,EAC5B,MAAM,gEAAgE,CAAC;AAExE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,8BAA8B,uBACZ,MAAM,sBACN,MAAM,qBACP,yBAAyB,QACtC,6BAA6B,2CAGpC,yBAYF,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}
+{"version":3,"file":"create-safe-transaction-authority.d.ts","sourceRoot":"","sources":["../../../src/transactions/authority/create-safe-transaction-authority.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,yBAAyB,EAE5B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACH,6BAA6B,EAC7B,yBAAyB,EAC5B,MAAM,gEAAgE,CAAC;AAExE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,8BAA8B,GAChC,oBAAoB,MAAM,EAC1B,oBAAoB,MAAM,EAC1B,mBAAmB,yBAAyB,EAC5C,MAAM,6BAA6B,EACnC,gBAAW,EACX,kBAAsB,KACvB,yBAYF,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "@degenerate/generic",
-  "version": "0.2.7",
+  "version": "0.4.0",
   "description": "This contains the generic information needed for the ShareData Adaptive Framework Ecosystem (SAFE) network",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
     "compile": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
-    "test": "jest --forceExit --detectOpenHandles --verbose --silent=false --env node --config tsconfig.pkg.json",
-    "test:coverage": "jest --forceExit --coverage --detectOpenHandles --verbose --silent=false --env node  --config tsconfig.pkg.json",
+    "test": "jest --forceExit --detectOpenHandles --verbose --silent=false --env node",
+    "test:coverage": "jest --forceExit --coverage --detectOpenHandles --verbose --silent=false --env node ",
     "test:clearCache": "jest --clearCache"
   },
   "repository": {
@@ -32,30 +41,29 @@
     "@types/elliptic": "^6.4.18",
     "bip39": "^3.1.0",
     "elliptic": "^6.6.1",
-    "firebase-admin": "^13.0.1",
-    "firebase-functions": "^6.1.2",
-    "jsonwebtoken": "^9.0.2",
-    "zod": "^3.24.1"
+    "firebase-admin": "^13.9.0",
+    "jsonwebtoken": "^9.0.3",
+    "zod": "^4.4.3"
   },
-  "gitHead": "29034ad37b42e7ec71a842e679b6c8a257d7cb6a",
+  "gitHead": "9453d9ab785e03fd01eb5b408ed0e3ca22baefd5",
   "devDependencies": {
-    "@eslint/js": "^9.17.0",
+    "@eslint/js": "^10.0.1",
     "@types/eslint__js": "^8.42.3",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.10.2",
-    "@typescript-eslint/eslint-plugin": "^8.18.1",
-    "@typescript-eslint/parser": "^8.18.1",
-    "eslint": "^9.17.0",
-    "eslint-import-resolver-typescript": "^3.7.0",
-    "eslint-plugin-import": "^2.31.0",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.18",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^10.3.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.1"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3"
   },
   "engines": {
-    "node": "22.x"
+    "node": ">=22"
   }
 }

package/dist/models/share-data/share-data.d.ts

@@ -1,181 +0,0 @@
-import z from 'zod';
-/**
- * This contains the data for the share data object
- */
-export declare enum ShareDataTypes {
-    AUTHORIZATION = "AUTHORIZATION",
-    RULE = "RULE",
-    FUNCTION = "FUNCTION",
-    TRANSACTION_HISTORY = "TRANSACTION_HISTORY",
-    DATA = "DATA"
-}
-export declare const ShareDataTypesSchema: z.ZodEnum<["AUTHORIZATION", "RULE", "FUNCTION", "TRANSACTION_HISTORY", "DATA"]>;
-/**
- * This contains the interface for a data in a share data object
- */
-export declare const IShareDataSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-export type IShareData = z.infer<typeof IShareDataSchema>;
-/**
- * This contains the interface for a share function record in the share data object
- */
-export declare const IShareFunctionRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    groupingId: z.ZodString;
-    groupingName: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodString;
-    hash: z.ZodString;
-    stringifiedFunction: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    stringifiedFunction: string;
-    id: string;
-    name: string;
-    description: string;
-    groupingId: string;
-    groupingName: string;
-    hash: string;
-}, {
-    stringifiedFunction: string;
-    id: string;
-    name: string;
-    description: string;
-    groupingId: string;
-    groupingName: string;
-    hash: string;
-}>;
-export type IShareFunctionRecord = z.infer<typeof IShareFunctionRecordSchema>;
-/**
- * This contains the interface for a share function in the share data object
- */
-export declare const IShareFunctionSchema: z.ZodObject<{
-    input: z.ZodAny;
-    func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-    output: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    func: (...args: unknown[]) => unknown;
-    output?: any;
-    input?: any;
-}, {
-    func: (...args: unknown[]) => unknown;
-    output?: any;
-    input?: any;
-}>;
-export interface IShareFunction<TInput, TFunction extends (...args: any[]) => any, TOutput> {
-    input: TInput;
-    func: TFunction;
-    output: TOutput;
-}
-/**
- * This contains the interface for the rule failures in the share data object
- */
-export declare const IShareDataRuleFailuresSchema: z.ZodObject<{
-    ruleId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    ruleId: string;
-}, {
-    ruleId: string;
-}>;
-export type IShareDataRuleFailures = z.infer<typeof IShareDataRuleFailuresSchema>;
-/**
- * This contains the interface for the share transaction history in the share data object
- */
-export declare const IShareDataTransactionBaseSchema: z.ZodObject<{
-    ruleOutcome: z.ZodBoolean;
-    ruleFailures: z.ZodArray<z.ZodObject<{
-        ruleId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        ruleId: string;
-    }, {
-        ruleId: string;
-    }>, "many">;
-    transactionFunction: z.ZodObject<{
-        input: z.ZodAny;
-        func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        output: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-}, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-}>;
-export type IShareDataTransactionBase = z.infer<typeof IShareDataTransactionBaseSchema>;
-/**
- * This contains the interface for the share transaction history in the share data object
- * This is done for storage
- */
-export declare const IShareDataTransactionHistorySchema: z.ZodObject<z.objectUtil.extendShape<{
-    ruleOutcome: z.ZodBoolean;
-    ruleFailures: z.ZodArray<z.ZodObject<{
-        ruleId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        ruleId: string;
-    }, {
-        ruleId: string;
-    }>, "many">;
-    transactionFunction: z.ZodObject<{
-        input: z.ZodAny;
-        func: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        output: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }, {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    }>;
-}, {
-    transactionId: z.ZodString;
-    transactionTime: z.ZodNumber;
-}>, "strip", z.ZodTypeAny, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-    transactionId: string;
-    transactionTime: number;
-}, {
-    ruleOutcome: boolean;
-    ruleFailures: {
-        ruleId: string;
-    }[];
-    transactionFunction: {
-        func: (...args: unknown[]) => unknown;
-        output?: any;
-        input?: any;
-    };
-    transactionId: string;
-    transactionTime: number;
-}>;
-export type IShareDataTransactionHistory = z.infer<typeof IShareDataTransactionHistorySchema>;
-//# sourceMappingURL=share-data.d.ts.map

package/dist/models/share-data/share-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"share-data.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;GAEG;AACH,oBAAY,cAAc;IACtB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,mBAAmB,wBAAwB;IAC3C,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,oBAAoB,iFAM/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oCAAoB,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;EAQrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAGH,MAAM,WAAW,cAAc,CAAC,MAAM,EAAE,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO;IACtF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACnB;AAGD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;EAEvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC"}