phygital-token-sdk 0.5.3 → 0.6.0

package/dist/utils/gating.d.ts

@@ -0,0 +1,195 @@
+import type { Address, Rpc, SolanaRpcApi } from "@solana/kit";
+type DasAssetAttribute = {
+    trait_type?: string;
+    value?: string | number;
+};
+type DasAsset = {
+    id: string;
+    grouping?: Array<[string, string] | {
+        group_key: string;
+        group_value: string;
+    }>;
+    token_info?: {
+        balance?: number;
+        decimals?: number;
+    };
+    content?: {
+        metadata?: {
+            attributes?: DasAssetAttribute[];
+        };
+    };
+};
+type GatingStringOp = {
+    op: "eq";
+    value: string;
+} | {
+    op: "neq";
+    value: string;
+} | {
+    op: "in";
+    values: readonly string[];
+} | {
+    op: "notIn";
+    values: readonly string[];
+};
+type GatingTraitOp = {
+    op: "eq";
+    value: string | number;
+} | {
+    op: "neq";
+    value: string | number;
+} | {
+    op: "in";
+    values: readonly (string | number)[];
+} | {
+    op: "notIn";
+    values: readonly (string | number)[];
+} | {
+    op: "gte";
+    value: number;
+} | {
+    op: "lte";
+    value: number;
+} | {
+    op: "between";
+    min: number;
+    max: number;
+};
+type GatingTrait = {
+    trait_type: string;
+} & GatingTraitOp;
+type GatingTraits = {
+    all: readonly GatingTrait[];
+} | {
+    any: readonly GatingTrait[];
+};
+type GatingBalance = {
+    min?: bigint;
+    max?: bigint;
+};
+export type GatingAssetPredicate = {
+    collection?: GatingStringOp;
+    mint?: GatingStringOp;
+    traits?: GatingTraits;
+    balance?: GatingBalance;
+};
+export type GatingFilter = {
+    count: {
+        min: number;
+        max?: number;
+        match: GatingAssetPredicate;
+    };
+} | {
+    totalBalance: {
+        mint: string;
+        min?: bigint;
+        max?: bigint;
+    };
+} | {
+    and: GatingFilter[];
+} | {
+    or: GatingFilter[];
+} | {
+    not: GatingFilter;
+};
+export type GatingFilterResult = {
+    kind: "count";
+    filter: {
+        count: {
+            min: number;
+            max?: number;
+            match: GatingAssetPredicate;
+        };
+    };
+    passed: boolean;
+    matchCount: number;
+} | {
+    kind: "totalBalance";
+    filter: {
+        totalBalance: {
+            mint: string;
+            min?: bigint;
+            max?: bigint;
+        };
+    };
+    passed: boolean;
+    total: bigint;
+} | {
+    kind: "and";
+    filter: {
+        and: GatingFilter[];
+    };
+    passed: boolean;
+    children: GatingFilterResult[];
+} | {
+    kind: "or";
+    filter: {
+        or: GatingFilter[];
+    };
+    passed: boolean;
+    children: GatingFilterResult[];
+} | {
+    kind: "not";
+    filter: {
+        not: GatingFilter;
+    };
+    passed: boolean;
+    child: GatingFilterResult;
+};
+export type GatingTier<TId extends string = string> = {
+    id: TId;
+    filter: GatingFilter;
+};
+export type GatingTierEvaluationResult<TId extends string = string> = {
+    id: TId;
+    passed: boolean;
+    filterResult: GatingFilterResult;
+};
+export type GatingTiersEvaluationResult<TId extends string = string> = {
+    tiers: GatingTierEvaluationResult<TId>[];
+    passedTierIds: TId[];
+    passed: boolean;
+};
+export type GatingEvaluationResult<TId extends string = string> = GatingTiersEvaluationResult<TId> & {
+    owner: Address;
+};
+export type EvaluateAssetGatingOptions<TId extends string = string> = {
+    assetPublicKey: string;
+    rpc: Rpc<SolanaRpcApi>;
+    tiers: readonly GatingTier<TId>[];
+};
+export declare const Gating: {
+    readonly and: (...filters: GatingFilter[]) => GatingFilter;
+    readonly or: (...filters: GatingFilter[]) => GatingFilter;
+    readonly not: (filter: GatingFilter) => GatingFilter;
+    readonly tier: <TId extends string>(id: TId, filter: GatingFilter) => GatingTier<TId>;
+    readonly count: (min: number, match: GatingAssetPredicate, max?: number) => GatingFilter;
+    readonly totalBalance: (mint: string, min?: bigint, max?: bigint) => GatingFilter;
+    readonly eq: (value: string) => GatingStringOp;
+    readonly neq: (value: string) => GatingStringOp;
+    readonly in: (...values: string[]) => GatingStringOp;
+    readonly notIn: (...values: string[]) => GatingStringOp;
+    readonly trait: (trait_type: string, op: GatingTraitOp) => GatingTrait;
+    readonly traitsAll: (...traits: GatingTrait[]) => GatingTraits;
+    readonly traitsAny: (...traits: GatingTrait[]) => GatingTraits;
+    readonly balance: (min?: bigint, max?: bigint) => GatingBalance;
+};
+export declare const GatingTraitValue: {
+    readonly eq: (value: string | number) => GatingTraitOp;
+    readonly neq: (value: string | number) => GatingTraitOp;
+    readonly in: (...values: (string | number)[]) => GatingTraitOp;
+    readonly notIn: (...values: (string | number)[]) => GatingTraitOp;
+    readonly gte: (value: number) => GatingTraitOp;
+    readonly lte: (value: number) => GatingTraitOp;
+    readonly between: (min: number, max: number) => GatingTraitOp;
+};
+export declare function assetMatchesPredicate(asset: DasAsset, predicate: GatingAssetPredicate): boolean;
+export declare function evaluateGatingFilter(assets: DasAsset[], filter: GatingFilter): GatingFilterResult;
+export declare function formatGatingPredicate(predicate: GatingAssetPredicate): string;
+export declare function summarizeGatingFailure(result: GatingFilterResult): string[];
+export declare function summarizeGatingTierFailure(tier: GatingTierEvaluationResult): string[];
+export declare function summarizeGatingEvaluationFailure<TId extends string>(result: GatingTiersEvaluationResult<TId> | GatingEvaluationResult<TId>): string[];
+export declare function evaluateGatingTiers<TId extends string>(assets: DasAsset[], tiers: readonly GatingTier<TId>[]): GatingTiersEvaluationResult<TId>;
+export declare function evaluateAssetGating<TId extends string>(options: EvaluateAssetGatingOptions<TId>): Promise<GatingEvaluationResult<TId>>;
+export {};
+//# sourceMappingURL=gating.d.ts.map

package/dist/utils/gating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gating.d.ts","sourceRoot":"","sources":["../../src/utils/gating.ts"],"names":[],"mappings":"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"}

package/dist/utils/gating.js

@@ -0,0 +1,481 @@
+import { fetchAsset } from "../generated/index.js";
+import { parseSecp256r1Pubkey } from "../instructions/mint.js";
+import { findAssetPda } from "./pdas/asset.js";
+export const Gating = {
+    and(...filters) {
+        return { and: filters };
+    },
+    or(...filters) {
+        return { or: filters };
+    },
+    not(filter) {
+        return { not: filter };
+    },
+    tier(id, filter) {
+        return { id, filter };
+    },
+    count(min, match, max) {
+        return { count: { min, max, match } };
+    },
+    totalBalance(mint, min, max) {
+        return { totalBalance: { mint, min, max } };
+    },
+    eq(value) {
+        return { op: "eq", value };
+    },
+    neq(value) {
+        return { op: "neq", value };
+    },
+    in(...values) {
+        return { op: "in", values };
+    },
+    notIn(...values) {
+        return { op: "notIn", values };
+    },
+    trait(trait_type, op) {
+        return { trait_type, ...op };
+    },
+    traitsAll(...traits) {
+        return { all: traits };
+    },
+    traitsAny(...traits) {
+        return { any: traits };
+    },
+    balance(min, max) {
+        return { min, max };
+    },
+};
+export const GatingTraitValue = {
+    eq(value) {
+        return { op: "eq", value };
+    },
+    neq(value) {
+        return { op: "neq", value };
+    },
+    in(...values) {
+        return { op: "in", values };
+    },
+    notIn(...values) {
+        return { op: "notIn", values };
+    },
+    gte(value) {
+        return { op: "gte", value };
+    },
+    lte(value) {
+        return { op: "lte", value };
+    },
+    between(min, max) {
+        return { op: "between", min, max };
+    },
+};
+async function fetchAssetOwner(rpc, assetPublicKey) {
+    const assetPda = await findAssetPda(parseSecp256r1Pubkey(assetPublicKey));
+    const account = await fetchAsset(rpc, assetPda);
+    return account.data.owner;
+}
+function createSearchAssetsClient(rpc) {
+    return async (params) => {
+        const rpcWithExecute = rpc;
+        return rpcWithExecute
+            .execute({ methodName: "searchAssets", params })
+            .send();
+    };
+}
+async function fetchOwnerDasAssets(owner, rpc) {
+    const searchAssets = createSearchAssetsClient(rpc);
+    const pageSize = 1000;
+    const items = [];
+    let page = 1;
+    while (true) {
+        const result = await searchAssets({
+            ownerAddress: owner,
+            tokenType: "all",
+            page,
+            limit: pageSize,
+        });
+        items.push(...result.items);
+        if (result.items.length < pageSize) {
+            break;
+        }
+        if (result.total > 0 && items.length >= result.total) {
+            break;
+        }
+        page += 1;
+    }
+    return items;
+}
+function assetCollections(asset) {
+    const collections = [];
+    for (const entry of asset.grouping ?? []) {
+        if (Array.isArray(entry)) {
+            if (entry[0] === "collection") {
+                collections.push(entry[1]);
+            }
+            continue;
+        }
+        if (entry.group_key === "collection") {
+            collections.push(entry.group_value);
+        }
+    }
+    return collections;
+}
+function normalizeText(value) {
+    return String(value).trim().toLowerCase();
+}
+function parseNumericTraitValue(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function matchesStringOp(actual, op) {
+    switch (op.op) {
+        case "eq":
+            return actual === op.value;
+        case "neq":
+            return actual !== op.value;
+        case "in":
+            return op.values.includes(actual);
+        case "notIn":
+            return !op.values.includes(actual);
+    }
+}
+function traitEntriesForType(asset, traitType) {
+    const normalizedType = traitType.trim().toLowerCase();
+    return (asset.content?.metadata?.attributes ?? []).filter((entry) => {
+        return (entry.trait_type !== undefined &&
+            entry.value !== undefined &&
+            entry.trait_type.trim().toLowerCase() === normalizedType);
+    });
+}
+function matchesTraitOp(asset, trait) {
+    const entries = traitEntriesForType(asset, trait.trait_type);
+    switch (trait.op) {
+        case "eq":
+            return entries.some((entry) => normalizeText(entry.value) === normalizeText(trait.value));
+        case "neq":
+            return (entries.length === 0 ||
+                entries.every((entry) => normalizeText(entry.value) !== normalizeText(trait.value)));
+        case "in": {
+            const allowed = new Set(trait.values.map(normalizeText));
+            return entries.some((entry) => allowed.has(normalizeText(entry.value)));
+        }
+        case "notIn": {
+            const blocked = new Set(trait.values.map(normalizeText));
+            return (entries.length === 0 ||
+                entries.every((entry) => !blocked.has(normalizeText(entry.value))));
+        }
+        case "gte":
+            return entries.some((entry) => {
+                const numeric = parseNumericTraitValue(entry.value);
+                return numeric !== undefined && numeric >= trait.value;
+            });
+        case "lte":
+            return entries.some((entry) => {
+                const numeric = parseNumericTraitValue(entry.value);
+                return numeric !== undefined && numeric <= trait.value;
+            });
+        case "between":
+            return entries.some((entry) => {
+                const numeric = parseNumericTraitValue(entry.value);
+                return (numeric !== undefined &&
+                    numeric >= trait.min &&
+                    numeric <= trait.max);
+            });
+    }
+}
+function matchesTraits(asset, traits) {
+    if ("all" in traits) {
+        return traits.all.every((trait) => matchesTraitOp(asset, trait));
+    }
+    return traits.any.some((trait) => matchesTraitOp(asset, trait));
+}
+function assetBalance(asset) {
+    const balance = asset.token_info?.balance;
+    if (balance === undefined) {
+        return 0n;
+    }
+    return BigInt(balance);
+}
+function matchesBalance(asset, balance) {
+    const amount = assetBalance(asset);
+    if (balance.min !== undefined && amount < balance.min) {
+        return false;
+    }
+    if (balance.max !== undefined && amount > balance.max) {
+        return false;
+    }
+    return true;
+}
+export function assetMatchesPredicate(asset, predicate) {
+    if (predicate.mint !== undefined && !matchesStringOp(asset.id, predicate.mint)) {
+        return false;
+    }
+    if (predicate.collection !== undefined) {
+        const collections = assetCollections(asset);
+        if (!collections.some((collection) => matchesStringOp(collection, predicate.collection))) {
+            return false;
+        }
+    }
+    if (predicate.traits !== undefined && !matchesTraits(asset, predicate.traits)) {
+        return false;
+    }
+    if (predicate.balance !== undefined && !matchesBalance(asset, predicate.balance)) {
+        return false;
+    }
+    return true;
+}
+function countMatchingAssets(assets, predicate) {
+    return assets.filter((asset) => assetMatchesPredicate(asset, predicate)).length;
+}
+function countInRange(count, min, max) {
+    if (count < min) {
+        return false;
+    }
+    if (max !== undefined && count > max) {
+        return false;
+    }
+    return true;
+}
+function amountInRange(amount, min, max) {
+    if (min !== undefined && amount < min) {
+        return false;
+    }
+    if (max !== undefined && amount > max) {
+        return false;
+    }
+    return true;
+}
+function totalBalanceForMint(assets, mint) {
+    let total = 0n;
+    for (const asset of assets) {
+        if (asset.id === mint) {
+            total += assetBalance(asset);
+        }
+    }
+    return total;
+}
+export function evaluateGatingFilter(assets, filter) {
+    if ("count" in filter) {
+        const matchCount = countMatchingAssets(assets, filter.count.match);
+        return {
+            kind: "count",
+            filter,
+            matchCount,
+            passed: countInRange(matchCount, filter.count.min, filter.count.max),
+        };
+    }
+    if ("totalBalance" in filter) {
+        const total = totalBalanceForMint(assets, filter.totalBalance.mint);
+        return {
+            kind: "totalBalance",
+            filter,
+            total,
+            passed: amountInRange(total, filter.totalBalance.min, filter.totalBalance.max),
+        };
+    }
+    if ("and" in filter) {
+        const children = filter.and.map((child) => evaluateGatingFilter(assets, child));
+        return {
+            kind: "and",
+            filter,
+            passed: children.every((child) => child.passed),
+            children,
+        };
+    }
+    if ("or" in filter) {
+        const children = filter.or.map((child) => evaluateGatingFilter(assets, child));
+        return {
+            kind: "or",
+            filter,
+            passed: children.some((child) => child.passed),
+            children,
+        };
+    }
+    if ("not" in filter) {
+        const child = evaluateGatingFilter(assets, filter.not);
+        return {
+            kind: "not",
+            filter,
+            passed: !child.passed,
+            child,
+        };
+    }
+    throw new Error("Invalid gating filter.");
+}
+function formatGatingStringOp(field, op) {
+    switch (op.op) {
+        case "eq":
+            return `${field} = ${op.value}`;
+        case "neq":
+            return `${field} != ${op.value}`;
+        case "in":
+            return `${field} in (${op.values.join(", ")})`;
+        case "notIn":
+            return `${field} not in (${op.values.join(", ")})`;
+    }
+}
+function formatGatingTraitOp(op) {
+    switch (op.op) {
+        case "eq":
+            return `= ${op.value}`;
+        case "neq":
+            return `!= ${op.value}`;
+        case "in":
+            return `in (${op.values.join(", ")})`;
+        case "notIn":
+            return `not in (${op.values.join(", ")})`;
+        case "gte":
+            return `>= ${op.value}`;
+        case "lte":
+            return `<= ${op.value}`;
+        case "between":
+            return `between ${op.min} and ${op.max}`;
+    }
+}
+function formatGatingTrait(trait) {
+    return `${trait.trait_type} ${formatGatingTraitOp(trait)}`;
+}
+export function formatGatingPredicate(predicate) {
+    const parts = [];
+    if (predicate.collection !== undefined) {
+        parts.push(formatGatingStringOp("collection", predicate.collection));
+    }
+    if (predicate.mint !== undefined) {
+        parts.push(formatGatingStringOp("mint", predicate.mint));
+    }
+    if (predicate.traits !== undefined) {
+        if ("all" in predicate.traits) {
+            parts.push(`traits all [${predicate.traits.all.map(formatGatingTrait).join("; ")}]`);
+        }
+        else {
+            parts.push(`traits any [${predicate.traits.any.map(formatGatingTrait).join("; ")}]`);
+        }
+    }
+    if (predicate.balance !== undefined) {
+        const { min, max } = predicate.balance;
+        if (min !== undefined && max !== undefined) {
+            parts.push(`balance between ${min} and ${max}`);
+        }
+        else if (min !== undefined) {
+            parts.push(`balance >= ${min}`);
+        }
+        else if (max !== undefined) {
+            parts.push(`balance <= ${max}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(", ") : "any asset";
+}
+function describeSatisfiedCondition(result) {
+    switch (result.kind) {
+        case "count":
+            return `${result.matchCount} asset(s) matching ${formatGatingPredicate(result.filter.count.match)}`;
+        case "totalBalance":
+            return `balance ${result.total} for mint ${result.filter.totalBalance.mint}`;
+        case "and":
+            return result.children.map(describeSatisfiedCondition).join("; ");
+        case "or": {
+            const passedChild = result.children.find((child) => child.passed);
+            return passedChild
+                ? describeSatisfiedCondition(passedChild)
+                : "an alternative condition";
+        }
+        case "not":
+            return `not (${describeSatisfiedCondition(result.child)})`;
+    }
+}
+function summarizeFailedNode(result) {
+    switch (result.kind) {
+        case "count": {
+            const { min, max, match } = result.filter.count;
+            const predicate = formatGatingPredicate(match);
+            const lines = [];
+            if (result.matchCount < min) {
+                lines.push(`Need at least ${min} asset(s) matching ${predicate}; found ${result.matchCount}.`);
+            }
+            if (max !== undefined && result.matchCount > max) {
+                lines.push(`Need at most ${max} asset(s) matching ${predicate}; found ${result.matchCount}.`);
+            }
+            if (lines.length === 0) {
+                lines.push(`Asset count requirement not met for ${predicate} (found ${result.matchCount}).`);
+            }
+            return lines;
+        }
+        case "totalBalance": {
+            const { mint, min, max } = result.filter.totalBalance;
+            const lines = [];
+            if (min !== undefined && result.total < min) {
+                lines.push(`Need at least ${min} raw balance for mint ${mint}; found ${result.total}.`);
+            }
+            if (max !== undefined && result.total > max) {
+                lines.push(`Need at most ${max} raw balance for mint ${mint}; found ${result.total}.`);
+            }
+            if (lines.length === 0) {
+                lines.push(`Balance requirement not met for mint ${mint} (found ${result.total}).`);
+            }
+            return lines;
+        }
+        case "and":
+            return result.children.flatMap((child) => summarizeGatingFailure(child));
+        case "or":
+            return [
+                "None of the alternative conditions were met:",
+                ...result.children.flatMap((child, index) => summarizeGatingFailure(child).map((line) => `  [${index + 1}] ${line}`)),
+            ];
+        case "not":
+            return [
+                `Must not satisfy: ${describeSatisfiedCondition(result.child)}.`,
+            ];
+    }
+}
+export function summarizeGatingFailure(result) {
+    if (result.passed) {
+        return [];
+    }
+    return summarizeFailedNode(result);
+}
+export function summarizeGatingTierFailure(tier) {
+    return summarizeGatingFailure(tier.filterResult);
+}
+export function summarizeGatingEvaluationFailure(result) {
+    if (result.passed) {
+        return [];
+    }
+    return result.tiers.flatMap((tier) => {
+        const reasons = summarizeGatingTierFailure(tier);
+        if (reasons.length === 0) {
+            return [];
+        }
+        return [`Tier "${tier.id}":`, ...reasons.map((line) => `  ${line}`)];
+    });
+}
+export function evaluateGatingTiers(assets, tiers) {
+    const tierResults = tiers.map((tier) => {
+        const filterResult = evaluateGatingFilter(assets, tier.filter);
+        return {
+            id: tier.id,
+            passed: filterResult.passed,
+            filterResult,
+        };
+    });
+    const passedTierIds = tierResults
+        .filter((tier) => tier.passed)
+        .map((tier) => tier.id);
+    return {
+        tiers: tierResults,
+        passedTierIds,
+        passed: passedTierIds.length > 0,
+    };
+}
+export async function evaluateAssetGating(options) {
+    const { assetPublicKey, rpc, tiers } = options;
+    const owner = await fetchAssetOwner(rpc, assetPublicKey);
+    const assets = await fetchOwnerDasAssets(owner, rpc);
+    const tierEvaluation = evaluateGatingTiers(assets, tiers);
+    return {
+        ...tierEvaluation,
+        owner,
+    };
+}
+//# sourceMappingURL=gating.js.map