@biconomy/abstractjs/dist/_esm/account/decorators/buildActionPolicy.js

SDK for Biconomy integration with support for account abstraction, smart accounts, ERC-4337.

import { toBytes, toHex } from "viem";
import { getSpendingLimitsPolicy, getSudoPolicy, getTimeFramePolicy, getUniversalActionPolicy, getUsageLimitPolicy } from "../../constants/index.js";
import { ParamCondition } from "../../modules/index.js";
import { toBytes32 } from "../utils/index.js";
export const UniversalPolicyAbi = [
    {
        components: [
            {
                name: "valueLimitPerUse",
                type: "uint256"
            },
            {
                components: [
                    {
                        name: "length",
                        type: "uint256"
                    },
                    {
                        components: [
                            {
                                name: "condition",
                                type: "uint8"
                            },
                            {
                                name: "offset",
                                type: "uint64"
                            },
                            {
                                name: "isLimited",
                                type: "bool"
                            },
                            {
                                name: "ref",
                                type: "bytes32"
                            },
                            {
                                components: [
                                    {
                                        name: "limit",
                                        type: "uint256"
                                    },
                                    {
                                        name: "used",
                                        type: "uint256"
                                    }
                                ],
                                name: "usage",
                                type: "tuple"
                            }
                        ],
                        name: "rules",
                        type: "tuple[16]"
                    }
                ],
                name: "paramRules",
                type: "tuple"
            }
        ],
        name: "ActionConfig",
        type: "tuple"
    }
];
/**
 * Maps human universal condition ("equal", etc) to ParamCondition enum.
 * @param conditionType Human-readable condition string.
 * @returns ParamCondition enum value.
 */
export const getUniversalActionPolicyConditionType = (conditionType) => {
    let condition = ParamCondition.EQUAL;
    switch (conditionType) {
        case "equal":
            condition = ParamCondition.EQUAL;
            break;
        case "greaterThan":
            condition = ParamCondition.GREATER_THAN;
            break;
        case "lessThan":
            condition = ParamCondition.LESS_THAN;
            break;
        case "greaterThanOrEqual":
            condition = ParamCondition.GREATER_THAN_OR_EQUAL;
            break;
        case "lessThanOrEqual":
            condition = ParamCondition.LESS_THAN_OR_EQUAL;
            break;
        case "notEqual":
            condition = ParamCondition.NOT_EQUAL;
            break;
        default:
            condition = ParamCondition.EQUAL;
            break;
    }
    return condition;
};
// 32 bytes calldata param value
export const calldataArgument = (value) => {
    if (value <= 0) {
        throw new Error("Invalid calldata argument value");
    }
    return BigInt((value - 1) * 32);
};
/**
 * Prepares data for the Universal Action Policy, including parameter rules and per-action value limits.
 */
const getUniversalPolicy = (params) => {
    const { rules, valueLimitPerUse } = params;
    if (rules.length > 16) {
        throw new Error("Universal policy only supports 16 rules");
    }
    const paramRules = [];
    const defaultParamRule = {
        condition: ParamCondition.GREATER_THAN,
        isLimited: false,
        offset: calldataArgument(1),
        ref: toHex(toBytes("0x", { size: 32 })),
        usage: { limit: BigInt(0), used: BigInt(0) }
    };
    for (let index = 0; index < 16; index++) {
        const configuredRule = rules[index];
        if (configuredRule) {
            paramRules.push({
                condition: getUniversalActionPolicyConditionType(configuredRule.condition),
                offset: configuredRule.calldataOffset,
                ref: toBytes32(configuredRule.comparisonValue),
                isLimited: configuredRule.isLimited ?? false,
                usage: configuredRule.usage || { limit: BigInt(0), used: BigInt(0) }
            });
        }
        else {
            paramRules.push(defaultParamRule);
        }
    }
    return getUniversalActionPolicy({
        paramRules: {
            length: BigInt(rules.length),
            rules: paramRules
        },
        valueLimitPerUse: valueLimitPerUse || 0n
    });
};
/**
 * Builds and returns the appropriate action policy based on the provided parameters (type and data).
 */
export const buildActionPolicy = (parameters) => {
    const { type } = parameters;
    switch (type) {
        case "sudo": {
            return getSudoPolicy();
        }
        case "universal": {
            return getUniversalPolicy(parameters);
        }
        case "timeframe": {
            return getTimeFramePolicy({
                validAfter: parameters.validAfter,
                validUntil: parameters.validUntil
            });
        }
        case "usageLimit": {
            return getUsageLimitPolicy({ limit: parameters.limit });
        }
        case "spendingLimits": {
            return getSpendingLimitsPolicy(parameters.tokenLimits);
        }
        default: {
            throw new Error(`Unknown build action policy type: ${type}`);
        }
    }
};
//# sourceMappingURL=buildActionPolicy.js.map