@solana/mpp 0.1.0 → 0.2.0

package/src/session/ChannelStore.ts

@@ -1,128 +0,0 @@
-import { Store } from 'mppx';
-
-import type { ChannelState } from './Types.js';
-
-const CHANNEL_KEY_PREFIX = 'solana-session:channel:';
-const storeCache = new WeakMap<Store.Store, ChannelStore>();
-
-export interface ChannelStore {
-    getChannel(channelId: string): Promise<ChannelState | null>;
-    updateChannel(
-        channelId: string,
-        updater: (current: ChannelState | null) => ChannelState | null,
-    ): Promise<ChannelState | null>;
-}
-
-export function fromStore(store: Store.Store): ChannelStore {
-    const cached = storeCache.get(store);
-    if (cached) {
-        return cached;
-    }
-
-    const locks = new Map<string, Promise<void>>();
-
-    async function update(
-        channelId: string,
-        updater: (current: ChannelState | null) => ChannelState | null,
-    ): Promise<ChannelState | null> {
-        const key = toStoreKey(channelId);
-
-        while (locks.has(key)) {
-            await locks.get(key);
-        }
-
-        let release!: () => void;
-        locks.set(
-            key,
-            new Promise<void>(resolve => {
-                release = resolve;
-            }),
-        );
-
-        try {
-            const current = await store.get<ChannelState | null>(key);
-            const next = updater(current);
-
-            if (next) {
-                await store.put(key, next);
-            } else {
-                await store.delete(key);
-            }
-
-            return next;
-        } finally {
-            locks.delete(key);
-            release();
-        }
-    }
-
-    const channelStore: ChannelStore = {
-        async getChannel(channelId) {
-            return await store.get<ChannelState | null>(toStoreKey(channelId));
-        },
-        async updateChannel(channelId, updater) {
-            return await update(channelId, updater);
-        },
-    };
-
-    storeCache.set(store, channelStore);
-    return channelStore;
-}
-
-export async function deductFromChannel(
-    store: ChannelStore,
-    channelId: string,
-    amount: bigint,
-): Promise<{ channel: ChannelState; ok: boolean }> {
-    if (amount < 0n) {
-        throw new Error('Deduction amount must be non-negative');
-    }
-
-    let deducted = false;
-
-    const channel = await store.updateChannel(channelId, current => {
-        deducted = false;
-
-        if (!current) {
-            return null;
-        }
-
-        const settledAmount = parseAtomicAmount(current.settledAmount, 'settledAmount');
-        const authorizedAmount = parseAtomicAmount(current.lastAuthorizedAmount, 'lastAuthorizedAmount');
-        const escrowedAmount = parseAtomicAmount(current.escrowedAmount, 'escrowedAmount');
-
-        const spendCeiling = authorizedAmount < escrowedAmount ? authorizedAmount : escrowedAmount;
-        const nextSettledAmount = settledAmount + amount;
-
-        if (nextSettledAmount > spendCeiling) {
-            return current;
-        }
-
-        deducted = true;
-        return {
-            ...current,
-            settledAmount: nextSettledAmount.toString(),
-        };
-    });
-
-    if (!channel) {
-        throw new Error('channel not found');
-    }
-
-    return {
-        channel,
-        ok: deducted,
-    };
-}
-
-function toStoreKey(channelId: string): string {
-    return `${CHANNEL_KEY_PREFIX}${channelId}`;
-}
-
-function parseAtomicAmount(value: string, field: string): bigint {
-    try {
-        return BigInt(value);
-    } catch {
-        throw new Error(`Invalid atomic amount in ${field}: ${value}`);
-    }
-}

package/src/session/Types.ts

@@ -1,189 +0,0 @@
-export type AuthorizationMode = 'regular_budget' | 'regular_unbounded' | 'swig_session';
-
-export interface SessionVoucher {
-    chainId: string;
-    channelId: string;
-    channelProgram: string;
-    cumulativeAmount: string;
-    expiresAt?: string;
-    meter: string;
-    payer: string;
-    recipient: string;
-    sequence: number;
-    serverNonce: string;
-    units: string;
-}
-
-export interface SignedSessionVoucher {
-    signature: string;
-    signatureType: 'ed25519' | 'swig-session';
-    signer: string;
-    voucher: SessionVoucher;
-}
-
-export interface ChannelState {
-    asset: { decimals: number; kind: 'sol' | 'spl'; mint?: string };
-    authority: {
-        delegatedSessionKey?: string;
-        swigRoleId?: number;
-        wallet: string;
-    };
-    authorizationMode: AuthorizationMode;
-    channelId: string;
-    createdAt: string;
-    escrowedAmount: string;
-    expiresAtUnix: number | null;
-    lastAuthorizedAmount: string;
-    lastSequence: number;
-    openSlot: number;
-    payer: string;
-    recipient: string;
-    serverNonce: string;
-    settledAmount: string;
-    status: 'closed' | 'closing' | 'expired' | 'open';
-}
-
-export type SessionCredentialPayload =
-    | {
-          action: 'close';
-          channelId: string;
-          closeTx?: string;
-          voucher: SignedSessionVoucher;
-      }
-    | {
-          action: 'open';
-          authorizationMode: AuthorizationMode;
-          capabilities?: {
-              allowedActions?: string[];
-              maxCumulativeAmount?: string;
-          };
-          channelId: string;
-          depositAmount: string;
-          expiresAt?: string;
-          openTx: string;
-          payer: string;
-          voucher: SignedSessionVoucher;
-      }
-    | {
-          action: 'topup';
-          additionalAmount: string;
-          channelId: string;
-          topupTx: string;
-      }
-    | {
-          action: 'update';
-          channelId: string;
-          voucher: SignedSessionVoucher;
-      };
-
-export interface VoucherVerifier {
-    verify(voucher: SignedSessionVoucher, channel: ChannelState): Promise<boolean>;
-}
-
-export interface SessionAuthorizer {
-    authorizeClose(input: AuthorizeCloseInput): Promise<AuthorizedClose>;
-    authorizeOpen(input: AuthorizeOpenInput): Promise<AuthorizedOpen>;
-    authorizeTopup(input: AuthorizeTopupInput): Promise<AuthorizedTopup>;
-    authorizeUpdate(input: AuthorizeUpdateInput): Promise<AuthorizedUpdate>;
-    getCapabilities(): AuthorizerCapabilities;
-    getMode(): AuthorizationMode;
-}
-
-export interface AuthorizeOpenInput {
-    asset: { decimals: number; kind: 'sol' | 'spl'; mint?: string };
-    channelId: string;
-    channelProgram: string;
-    depositAmount: string;
-    network: string;
-    pricing?: { amountPerUnit: string; meter: string; unit: string };
-    recipient: string;
-    serverNonce: string;
-}
-
-export interface AuthorizedOpen {
-    capabilities: AuthorizerCapabilities;
-    expiresAt?: string;
-    openTx: string;
-    voucher: SignedSessionVoucher;
-}
-
-export interface AuthorizeUpdateInput {
-    channelId: string;
-    channelProgram: string;
-    cumulativeAmount: string;
-    meter: string;
-    network: string;
-    recipient: string;
-    sequence: number;
-    serverNonce: string;
-    units: string;
-}
-
-export interface AuthorizedUpdate {
-    voucher: SignedSessionVoucher;
-}
-
-export interface AuthorizeTopupInput {
-    additionalAmount: string;
-    channelId: string;
-    channelProgram: string;
-    network: string;
-}
-
-export interface AuthorizedTopup {
-    topupTx: string;
-}
-
-export interface AuthorizeCloseInput {
-    channelId: string;
-    channelProgram: string;
-    finalCumulativeAmount: string;
-    network: string;
-    recipient: string;
-    sequence: number;
-    serverNonce: string;
-}
-
-export interface AuthorizedClose {
-    closeTx?: string;
-    voucher: SignedSessionVoucher;
-}
-
-export interface AuthorizerCapabilities {
-    allowedActions?: Array<'close' | 'open' | 'topup' | 'update'>;
-    allowedPrograms?: string[];
-    expiresAt?: string;
-    maxCumulativeAmount?: string;
-    maxDepositAmount?: string;
-    mode: AuthorizationMode;
-    requiresInteractiveApproval: {
-        close: boolean;
-        open: boolean;
-        topup: boolean;
-        update: boolean;
-    };
-}
-
-export type SessionPolicyProfile =
-    | {
-          autoTopup?: {
-              amount: string;
-              enabled: boolean;
-              triggerBelow: string;
-          };
-          depositLimit?: string;
-          profile: 'swig-time-bound';
-          spendLimit?: string;
-          ttlSeconds: number;
-      }
-    | {
-          maxCumulativeAmount: string;
-          maxDepositAmount?: string;
-          profile: 'wallet-budget';
-          requireApprovalOnTopup?: boolean;
-          validUntil?: string;
-      }
-    | {
-          profile: 'wallet-manual';
-          requireApprovalOnEveryUpdate: boolean;
-      };

package/src/session/Voucher.ts

@@ -1,158 +0,0 @@
-import {
-    address,
-    createSignableMessage,
-    getBase58Decoder,
-    getBase58Encoder,
-    getPublicKeyFromAddress,
-    type MessagePartialSigner,
-    signatureBytes,
-    verifySignature,
-} from '@solana/kit';
-
-import type { SessionVoucher, SignedSessionVoucher } from './Types.js';
-
-const DOMAIN_SEPARATOR = 'solana-mpp-session-voucher-v1:';
-const textEncoder = new TextEncoder();
-const base58Encoder = getBase58Encoder();
-const base58Decoder = getBase58Decoder();
-
-export function serializeVoucher(voucher: SessionVoucher): Uint8Array {
-    const canonical = JSON.stringify(canonicalize(voucher));
-    return textEncoder.encode(`${DOMAIN_SEPARATOR}${canonical}`);
-}
-
-export async function signVoucher(
-    signer: MessagePartialSigner,
-    voucher: SessionVoucher,
-): Promise<SignedSessionVoucher> {
-    const signable = createSignableMessage(serializeVoucher(voucher));
-    const [signatureDictionary] = await signer.signMessages([signable]);
-    const signatureValue = signatureDictionary[signer.address];
-
-    if (!signatureValue) {
-        throw new Error('Signer did not produce a voucher signature');
-    }
-
-    return {
-        signature: base58Decoder.decode(signatureValue),
-        signatureType: 'ed25519',
-        signer: signer.address,
-        voucher,
-    };
-}
-
-export async function verifyVoucherSignature(signed: SignedSessionVoucher): Promise<boolean> {
-    if (signed.signatureType !== 'ed25519' && signed.signatureType !== 'swig-session') {
-        return false;
-    }
-
-    try {
-        const publicKey = await getPublicKeyFromAddress(address(signed.signer));
-        const signature = signatureBytes(base58Encoder.encode(signed.signature));
-        const serialized = serializeVoucher(signed.voucher);
-        return await verifySignature(publicKey, signature, serialized);
-    } catch {
-        return false;
-    }
-}
-
-export function parseVoucherFromPayload(payload: unknown): SignedSessionVoucher {
-    const maybeRoot = asRecord(payload, 'Session payload must be an object');
-    const source = hasSignedVoucherEnvelope(maybeRoot)
-        ? maybeRoot
-        : asRecord(maybeRoot.voucher, 'Payload must include a signed voucher in `voucher`');
-
-    const rawVoucher = asRecord(source.voucher, 'Signed voucher must include `voucher` object');
-
-    const signatureTypeRaw = readString(source, 'signatureType');
-    if (signatureTypeRaw !== 'ed25519' && signatureTypeRaw !== 'swig-session') {
-        throw new Error('Signed voucher `signatureType` must be "ed25519" or "swig-session"');
-    }
-
-    const expiresAt = readOptionalString(rawVoucher, 'expiresAt');
-
-    return {
-        signature: readString(source, 'signature'),
-        signatureType: signatureTypeRaw,
-        signer: readString(source, 'signer'),
-        voucher: {
-            channelId: readString(rawVoucher, 'channelId'),
-            cumulativeAmount: readString(rawVoucher, 'cumulativeAmount'),
-            meter: readString(rawVoucher, 'meter'),
-            payer: readString(rawVoucher, 'payer'),
-            recipient: readString(rawVoucher, 'recipient'),
-            sequence: readInteger(rawVoucher, 'sequence'),
-            units: readString(rawVoucher, 'units'),
-            ...(expiresAt !== undefined ? { expiresAt } : {}),
-            chainId: readString(rawVoucher, 'chainId'),
-            channelProgram: readString(rawVoucher, 'channelProgram'),
-            serverNonce: readString(rawVoucher, 'serverNonce'),
-        },
-    };
-}
-
-function canonicalize(value: unknown): unknown {
-    if (Array.isArray(value)) {
-        return value.map(item => canonicalize(item));
-    }
-
-    if (value && typeof value === 'object') {
-        const record = value as Record<string, unknown>;
-        const normalized: Record<string, unknown> = {};
-
-        for (const key of Object.keys(record).sort()) {
-            const item = record[key];
-            if (item !== undefined) {
-                normalized[key] = canonicalize(item);
-            }
-        }
-
-        return normalized;
-    }
-
-    return value;
-}
-
-function hasSignedVoucherEnvelope(value: Record<string, unknown>): value is {
-    signature: unknown;
-    signatureType: unknown;
-    signer: unknown;
-    voucher: unknown;
-} {
-    return 'voucher' in value && 'signer' in value && 'signature' in value && 'signatureType' in value;
-}
-
-function asRecord(value: unknown, message: string): Record<string, unknown> {
-    if (!value || typeof value !== 'object') {
-        throw new Error(message);
-    }
-
-    return value as Record<string, unknown>;
-}
-
-function readString(record: Record<string, unknown>, key: string): string {
-    const value = record[key];
-    if (typeof value !== 'string') {
-        throw new Error(`Expected string field: ${key}`);
-    }
-    return value;
-}
-
-function readOptionalString(record: Record<string, unknown>, key: string): string | undefined {
-    const value = record[key];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'string') {
-        throw new Error(`Expected optional string field: ${key}`);
-    }
-    return value;
-}
-
-function readInteger(record: Record<string, unknown>, key: string): number {
-    const value = record[key];
-    if (!Number.isInteger(value)) {
-        throw new Error(`Expected integer field: ${key}`);
-    }
-    return value as number;
-}