@guildxyz/types
Version:
Types related to the Guild.xyz API
1,482 lines (1,448 loc) • 77.8 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// index.ts
var types_exports2 = {};
__export(types_exports2, {
consts: () => consts_exports,
schemas: () => schemas_exports,
types: () => types_exports
});
module.exports = __toCommonJS(types_exports2);
// consts.ts
var consts_exports = {};
__export(consts_exports, {
AUTH_HEADER_NAME: () => AUTH_HEADER_NAME,
AuthMethod: () => AuthMethod,
CORRELATION_ID_HEADER_NAME: () => CORRELATION_ID_HEADER_NAME,
Chain: () => Chain,
ChainIds: () => ChainIds,
ContactType: () => ContactType,
ErrorMessages: () => ErrorMessages,
FeeCollectorContracts: () => FeeCollectorContracts,
GuildPinAction: () => GuildPinAction,
GuildSortType: () => GuildSortType,
Logic: () => Logic,
NFTRewardFactoryAddresses: () => NFTRewardFactoryAddresses,
NFTRewardSupportedChains: () => NFTRewardSupportedChains,
PARAMS_HEADER_NAME: () => PARAMS_HEADER_NAME,
PLATFORM_NAMES_IDS: () => PLATFORM_NAMES_IDS,
PRIVILEGED_USER_ID_HEADER: () => PRIVILEGED_USER_ID_HEADER,
PaymentSupportedChains: () => PaymentSupportedChains,
PinContractAddresses: () => PinContractAddresses,
PinSupportedChains: () => PinSupportedChains,
PlatformName: () => PlatformName,
SDK_PROJECT_NAME_HEADER_NAME: () => SDK_PROJECT_NAME_HEADER_NAME,
SDK_VERSION_HEADER_NAME: () => SDK_VERSION_HEADER_NAME,
SERVICE_HEADER_NAME: () => SERVICE_HEADER_NAME,
SIG_HEADER_NAME: () => SIG_HEADER_NAME,
SocialLinks: () => SocialLinks,
UniswapV3FactoryAddresses: () => UniswapV3FactoryAddresses,
UniswapV3PositionsAddresses: () => UniswapV3PositionsAddresses,
UniswapV3PositionsChains: () => UniswapV3PositionsChains,
VISIBILITY_FILTERED_COUNT_HEADER_NAME: () => VISIBILITY_FILTERED_COUNT_HEADER_NAME,
Visibility: () => Visibility,
XPEventType: () => XPEventType,
unimplementedRequirementTypes: () => unimplementedRequirementTypes,
walletTypes: () => walletTypes
});
var SocialLinks = [
"TWITTER",
"LENS",
"YOUTUBE",
"SPOTIFY",
"MIRROR",
"MEDIUM",
"SUBSTACK",
"SNAPSHOT",
"SOUND",
"GITHUB",
"WARPCAST",
"WEBSITE"
];
var Visibility = ["PUBLIC", "PRIVATE", "HIDDEN"];
var ChainIds = {
ETHEREUM: 1,
POLYGON: 137,
BSC: 56,
FANTOM: 250,
ARBITRUM: 42161,
NOVA: 42170,
CELO: 42220,
HARMONY: 16666e5,
GOERLI: 5,
AVALANCHE: 43114,
OPTIMISM: 10,
MOONRIVER: 1285,
MOONBEAM: 1284,
GNOSIS: 100,
METIS: 1088,
CRONOS: 25,
BOBA: 288,
BOBA_AVAX: 43288,
PALM: 11297108109,
BASE_GOERLI: 84531,
BASE_MAINNET: 8453,
EXOSAMA: 2109,
EVMOS: 9001,
POLYGON_MUMBAI: 80001,
ZETACHAIN_ATHENS: 7001,
SCROLL_ALPHA: 534353,
ZORA: 7777777,
SEPOLIA: 11155111,
ZKSYNC_ERA: 324,
POLYGON_ZKEVM: 1101,
NEON_EVM: 245022934,
PGN: 424,
LINEA: 59144,
LUKSO: 42,
MANTLE: 5e3,
SCROLL: 534352,
SCROLL_SEPOLIA: 534351,
RONIN: 2020,
SHIMMER: 148,
KAVA: 2222,
BITFINITY_TESTNET: 355113,
X1_TESTNET: 195,
ONTOLOGY: 58,
BERA_TESTNET: 2061,
MANTA: 169,
TAIKO_KATLA: 167008,
OASIS_SAPPHIRE: 23294,
BLAST_SEPOLIA: 168587773,
BASE_SEPOLIA: 84532,
BLAST_MAINNET: 81457,
ASTAR_ZKEVM: 3776,
ZETACHAIN: 7e3,
CORE_DAO: 1116,
LISK_SEPOLIA: 4202,
FORM: 478,
METIS_SEPOLIA: 59902,
OP_BNB: 204,
X1: 196,
CYBER: 7560,
TAIKO: 167e3,
KLAYTN: 8217,
MINT: 185,
WORLD_CHAIN: 480,
SEI: 1329,
FILECOIN: 314,
ROOTSTOCK: 30,
MODE: 34443,
LISK: 1135,
CRONOS_ZKEVM: 388,
INK_SEPOLIA: 763373,
INK: 57073,
IOTA: 8822,
SONIC: 146,
SOPHON: 50104,
ZERO: 543210,
XDC: 50,
SONEIUM: 1868
};
var Chain = Object.keys(ChainIds);
var PLATFORM_NAMES_IDS = {
DISCORD: 1,
TELEGRAM: 2,
GITHUB: 3,
GOOGLE: 4,
TWITTER: 5,
// "STEAM": 6,
CONTRACT_CALL: 7,
TWITTER_V1: 8,
UNIQUE_TEXT: 9,
TEXT: 10,
GUILD_PIN: 11,
POINTS: 13,
POAP: 14,
FORM: 15,
GATHER_TOWN: 16,
ERC20: 17,
WORLD_ID: 18,
FARCASTER_CHANNEL: 19
};
var PlatformName = Object.keys(PLATFORM_NAMES_IDS);
var Logic = ["AND", "OR", "ANY_OF"];
var ErrorMessages = {
INVALID_GUILDPLATFORM_INDEX: "Invalid guildPlatformIndex. Make sure all guildPlatformIndex values reference an existing item from guildPlatforms",
EMPTY_OBJECT: "At least one of the fields must be defined",
INVALID_ADDRESS: "Invalid address",
REQUIRED_PLATFORM_GUILD_DATA: "platformGuildData is required",
ADMIN_UPDATE_IS_OWNER_FALSE: "It is only possible to update an admin to be an owner. But doing so the previous owner will lose ownership"
};
var GuildPinAction = ["JOINED_GUILD", "IS_OWNER", "IS_ADMIN"];
var XPEventType = [
"USER_REFERRAL",
"JOIN_GUILD",
"GET_ROLE",
"SUBMIT_FORM",
"COLLECT_PIN",
"COLLECT_NFT",
"OWN_GUILD_VERIFIED"
];
var PinSupportedChains = {
10: "OPTIMISM",
25: "CRONOS",
56: "BSC",
58: "ONTOLOGY",
137: "POLYGON",
146: "SONIC",
185: "MINT",
324: "ZKSYNC_ERA",
478: "FORM",
1135: "LISK",
5e3: "MANTLE",
7560: "CYBER",
8453: "BASE_MAINNET",
8822: "IOTA",
34443: "MODE",
42161: "ARBITRUM",
50104: "SOPHON",
57073: "INK",
59144: "LINEA",
543210: "ZERO",
50: "XDC",
1868: "SONEIUM",
11155111: "SEPOLIA",
// Use a fake chainId for Fuel
123456789: "FUEL"
};
var PinContractAddresses = {
POLYGON: "0xff04820c36759c9f5203021fe051239ad2dcca8a",
BASE_MAINNET: "0x326f14942f8899406e3224bd63e9f250d275a52e",
ZKSYNC_ERA: "0xd1e4254fe7e56f58777ba624e7eeb3644f872b0d",
BSC: "0x807f16eba4a2c51b86cb8ec8be8eab34305c2bfd",
ARBITRUM: "0x0e6a14106497a7de36fba446628860c062e9e302",
CRONOS: "0x4205e56a69a0130a9e0828d45d0c84e45340a196",
OPTIMISM: "0x6c2c223b84724c4b8fd41ae0142c2369dfa7e319",
MANTLE: "0x4205e56a69a0130a9e0828d45d0c84e45340a196",
ONTOLOGY: "0x4205e56a69a0130a9e0828d45d0c84e45340a196",
LINEA: "0x4205e56a69a0130a9e0828d45d0c84e45340a196",
CYBER: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
MINT: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
MODE: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
LISK: "0x73d1a63bce3083be47597E2Ef0646BbFd1907f1C",
FORM: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
INK: "0x73d1a63bce3083be47597E2Ef0646BbFd1907f1C",
IOTA: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
SONIC: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
// SOPHON: "0xTODO",
ZERO: "0x792c4f33cABa7B0631c2B6a3355fEad6D9DCaCC9",
XDC: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
SONEIUM: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
SEPOLIA: "0xac49ee0c3bda5f851eac9a3184a21041e9afe379"
};
var NFTRewardSupportedChains = [
"ETHEREUM",
"BASE_MAINNET",
"OPTIMISM",
"BSC",
"CRONOS",
"POLYGON",
"MANTLE",
"ZKSYNC_ERA",
"LINEA",
"CYBER",
"ARBITRUM",
"SCROLL",
"TAIKO",
"BLAST_MAINNET",
"X1",
"CORE_DAO",
"METIS",
"NEON_EVM",
"POLYGON_ZKEVM",
"ZETACHAIN",
"MINT",
"MODE",
"AVALANCHE",
"LISK",
"INK",
"IOTA",
"SONIC",
// "SOPHON",
"ZERO",
"XDC",
"SONEIUM",
"SEPOLIA"
];
var NFTRewardFactoryAddresses = {
ETHEREUM: "0x6ee2dd02fbfb71f518827042b6adca242f1ba0b2",
BASE_MAINNET: "0x4205e56a69a0130a9e0828d45d0c84e45340a196",
OPTIMISM: "0xe6e6b676f94a6207882ac92b6014a391766fa96e",
BSC: "0xa445e7d3af54867d14467b44d5487352403d1e59",
CRONOS: "0x6c2c223b84724c4b8fd41ae0142c2369dfa7e319",
POLYGON: "0xc1c23618110277ffe6d529816eb23de42b24cc33",
MANTLE: "0x326f14942f8899406e3224bd63E9f250D275a52e",
ZKSYNC_ERA: "0x2a1eaf11a9753a871b15e2865d8a47cf17dd9450",
LINEA: "0x326f14942f8899406e3224bd63E9f250D275a52e",
CYBER: "0x097E05f7a194a30A482CC9616460498980bE79d3",
ARBITRUM: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
SCROLL: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
TAIKO: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
BLAST_MAINNET: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
X1: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
CORE_DAO: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
METIS: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
NEON_EVM: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
POLYGON_ZKEVM: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
ZETACHAIN: "0x13ec6B98362E43Add08f7CC4f6befd02fa52eE01",
MINT: "0x097E05f7a194a30A482CC9616460498980bE79d3",
MODE: "0x097E05f7a194a30A482CC9616460498980bE79d3",
AVALANCHE: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
LISK: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
INK: "0x13ec6b98362e43add08f7cc4f6befd02fa52ee01",
SEPOLIA: "0xa9e8e62266d449b766d305075248790bdd46facb",
IOTA: "0x097E05f7a194a30A482CC9616460498980bE79d3",
SONIC: "0x070cD1FD4de1ed0259871B7d0b85C0e237702691",
// SOPHON: "0xTODO",
ZERO: "0x334f5BBDdCD9eAF0ad6B151e8D222f4fA54Fbc95",
XDC: "0x097E05f7a194a30A482CC9616460498980bE79d3",
SONEIUM: "0x097E05f7a194a30A482CC9616460498980bE79d3"
};
var GuildSortType = ["NEWEST", "VERIFIED", "FEATURED"];
var ContactType = ["EMAIL", "TELEGRAM"];
var AuthMethod = {
EOA: "1",
KeyPair: "2",
EIP1271: "3"
};
var PARAMS_HEADER_NAME = "x-guild-params";
var SIG_HEADER_NAME = "x-guild-sig";
var AUTH_HEADER_NAME = "x-guild-auth";
var SERVICE_HEADER_NAME = "x-guild-service";
var PRIVILEGED_USER_ID_HEADER = "x-guild-privileged-user-id";
var CORRELATION_ID_HEADER_NAME = "x-correlation-id";
var SDK_VERSION_HEADER_NAME = "x-guild-sdk-version";
var SDK_PROJECT_NAME_HEADER_NAME = "x-guild-sdk-project-name";
var VISIBILITY_FILTERED_COUNT_HEADER_NAME = "x-guild-visibility-filtered";
var unimplementedRequirementTypes = [
"ERC721",
"ERC1155",
"NOUNS",
"ERC20",
"SOUND_ARTIST_BACKED",
"SOUND_COLLECTED",
"SOUND_ARTIST",
"SOUND_TOP_COLLECTOR",
"SOUND_NFTS",
"UNLOCK",
"NOOX",
"YUP"
];
var UniswapV3PositionsChains = [
"ETHEREUM",
"ARBITRUM",
"OPTIMISM",
"POLYGON",
"BASE_MAINNET",
"BSC",
"AVALANCHE",
"CELO",
"BLAST_MAINNET",
"SEPOLIA",
"BASE_SEPOLIA"
];
var UniswapV3PositionsAddresses = {
ETHEREUM: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
ARBITRUM: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
OPTIMISM: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
POLYGON: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
CELO: "0x3d79EdAaBC0EaB6F08ED885C05Fc0B014290D95A",
BSC: "0x7b8A01B39D58278b5DE7e48c8449c9f4F5170613",
BASE_MAINNET: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
SEPOLIA: "0x1238536071E1c677A632429e3655c799b22cDA52",
BASE_SEPOLIA: "0x1238536071E1c677A632429e3655c799b22cDA52",
AVALANCHE: "0x655C406EBFa14EE2006250925e54ec43AD184f8B",
BLAST_MAINNET: "0xB218e4f7cF0533d4696fDfC419A0023D33345F28"
};
var UniswapV3FactoryAddresses = {
ETHEREUM: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
SEPOLIA: "0x0227628f3F023bb0B980b67D528571c95c6DaC1c",
ARBITRUM: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
OPTIMISM: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
POLYGON: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
BASE_MAINNET: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
BASE_SEPOLIA: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
BSC: "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
AVALANCHE: "0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD",
CELO: "0xAfE208a311B21f13EF87E33A90049fC17A7acDEc",
BLAST_MAINNET: "0x792edAdE80af5fC680d96a2eD80A44247D2Cf6Fd"
};
var PaymentSupportedChains = [
"ETHEREUM",
"POLYGON",
"OPTIMISM",
"SEPOLIA"
];
var FeeCollectorContracts = {
ETHEREUM: "0xe4b4c6a7c6b6396032096c12adf46b7f14a70f4d",
POLYGON: "0xe4b4c6a7c6b6396032096c12adf46b7f14a70f4d",
OPTIMISM: "0xf7c2baa81feb6dd7bda0b3a03afbc1e13f955da5",
SEPOLIA: "0xc3563655d35397b77228c07a7f5301b0e0fa417d"
};
var walletTypes = ["EVM", "FUEL"];
// schemas/index.ts
var schemas_exports = {};
__export(schemas_exports, {
AuthenticationParamsSchema: () => AuthenticationParamsSchema,
AuthenticationSchema: () => AuthenticationSchema,
ContractCallGuildRewardSchema: () => ContractCallGuildRewardSchema,
ContributionCollectionSchema: () => ContributionCollectionSchema,
ContributionCreationSchema: () => ContributionCreationSchema,
ContributionSchema: () => ContributionSchema,
ContributionUpdateSchema: () => ContributionUpdateSchema,
DynamicAmountSchema: () => DynamicAmountSchema,
ExperienceSchema: () => ExperienceSchema,
FarcasterProfileSchema: () => FarcasterProfileSchema,
FieldCreationPayloadSchema: () => FieldCreationPayloadSchema,
FieldSchema: () => FieldSchema,
FormCreationPayloadSchema: () => FormCreationPayloadSchema,
FormSchema: () => FormSchema,
GroupCreateSchema: () => GroupCreateSchema,
GroupSchema: () => GroupSchema,
GroupUpateSchema: () => GroupUpateSchema,
GuildAdminCreationPayloadSchema: () => GuildAdminCreationPayloadSchema,
GuildAdminUpdatePayloadSchema: () => GuildAdminUpdatePayloadSchema,
GuildContactCreationPayloadSchema: () => GuildContactCreationPayloadSchema,
GuildContactUpdatePayloadSchema: () => GuildContactUpdatePayloadSchema,
GuildCreationPayloadSchema: () => GuildCreationPayloadSchema,
GuildGetManyQueryParamsSchema: () => GuildGetManyQueryParamsSchema,
GuildRewardCreationSchema: () => GuildRewardCreationSchema,
GuildRewardSchema: () => GuildRewardSchema,
GuildRewardUpdateSchema: () => GuildRewardUpdateSchema,
GuildSchema: () => GuildSchema,
GuildSearchQueryParamsSchema: () => GuildSearchQueryParamsSchema,
GuildUpdatePayloadSchema: () => GuildUpdatePayloadSchema,
IssueGuildPinPayloadSchema: () => IssueGuildPinPayloadSchema,
JoinActionPayloadSchema: () => JoinActionPayloadSchema,
LinkParamsSchema: () => LinkParamsSchema2,
PlatformAccountDetailsSchema: () => PlatformAccountDetailsSchema,
PlatformUserCreationSchema: () => PlatformUserCreationSchema,
PlatformUserDataSchema: () => PlatformUserDataSchema,
ProfileCreationSchema: () => ProfileCreationSchema,
ProfileSchema: () => ProfileSchema,
ProfileUpdateSchema: () => ProfileUpdateSchema,
ProfileUsernameSchema: () => ProfileUsernameSchema,
PublicUserSchema: () => PublicUserSchema,
RequirementCreateResponseSchema: () => RequirementCreateResponseSchema,
RequirementCreationPayloadSchema: () => RequirementCreationPayloadSchema,
RequirementSchema: () => RequirementSchema,
RequirementTypeAndDataSchema: () => RequirementTypeAndDataSchema,
RequirementUpdatePayloadSchema: () => RequirementUpdatePayloadSchema,
RoleCreationForGuildCreationPayloadSchema: () => RoleCreationForGuildCreationPayloadSchema,
RoleCreationPayloadSchema: () => RoleCreationPayloadSchema,
RolePlatformClaimPayloadSchema: () => RolePlatformClaimPayloadSchema,
RoleRewardCreationForGuildCreationPayloadSchema: () => RoleRewardCreationForGuildCreationPayloadSchema,
RoleRewardCreationPayloadSchema: () => RoleRewardCreationPayloadSchema,
RoleRewardUpdatePayloadSchema: () => RoleRewardUpdatePayloadSchema,
RoleSchema: () => RoleSchema,
RoleUpdatePayloadSchema: () => RoleUpdatePayloadSchema,
StatusUpdateActionPayloadSchema: () => StatusUpdateActionPayloadSchema,
SubmissionAnswerSchema: () => SubmissionAnswerSchema,
SubmissionCreationAnswerSchema: () => SubmissionCreationAnswerSchema,
UserAddressCreationPayloadSchema: () => UserAddressCreationPayloadSchema,
UserAddressSchema: () => UserAddressSchema,
UserAddressUpdatePayloadSchema: () => UserAddressUpdatePayloadSchema,
UserSchema: () => UserSchema,
UserSharedSocialSchema: () => UserSharedSocialSchema,
UserSubmissionCreationSchema: () => UserSubmissionCreationSchema,
UserSubmissionSchema: () => UserSubmissionSchema,
UserSubmissionsSchema: () => UserSubmissionsSchema,
VerifyKeyPayloadSchema: () => VerifyKeyPayloadSchema
});
// schemas/actions.ts
var import_zod = require("zod");
var JoinActionPayloadSchema = import_zod.z.object({
guildId: import_zod.z.number().int().positive()
});
var StatusUpdateActionPayloadSchema = import_zod.z.object({
roleIds: import_zod.z.array(import_zod.z.number().int().positive()),
recheckAccess: import_zod.z.boolean().optional(),
updateMemberships: import_zod.z.boolean().optional(),
manageRewards: import_zod.z.boolean().optional(),
forceRewardActions: import_zod.z.boolean().optional(),
onlyForThisPlatform: import_zod.z.boolean().optional()
});
// schemas/auth.ts
var import_zod3 = require("zod");
// schemas/common.ts
var import_zod2 = require("zod");
var VisibilitySchema = import_zod2.z.enum(Visibility);
var ChainSchema = import_zod2.z.enum(Chain);
var PlatformNameSchema = import_zod2.z.enum(PlatformName);
var EvmAddressSchema = import_zod2.z.string().regex(/^0x[0-9a-f]{40}$/i, ErrorMessages.INVALID_ADDRESS).toLowerCase();
var FuelAddressSchema = import_zod2.z.string().regex(/^0x[0-9a-f]{64}$/i, ErrorMessages.INVALID_ADDRESS).toLowerCase();
var AnyAddressSchema = EvmAddressSchema.or(FuelAddressSchema);
var LogicSchema = import_zod2.z.enum(Logic);
var GuildPinActionSchema = import_zod2.z.enum(GuildPinAction);
var ContactTypeSchema = import_zod2.z.enum(ContactType);
var GuildSortTypeSchema = import_zod2.z.enum(GuildSortType);
var PositiveInteger = import_zod2.z.number().int().positive();
var DateLike = import_zod2.z.date().or(import_zod2.z.string().datetime());
// schemas/auth.ts
var AuthenticationParamsSchema = import_zod3.z.object({
addr: AnyAddressSchema,
nonce: import_zod3.z.string(),
msg: import_zod3.z.string(),
ts: import_zod3.z.string(),
hash: import_zod3.z.string().optional()
}).and(
import_zod3.z.union([
import_zod3.z.object({
chainId: import_zod3.z.string(),
method: import_zod3.z.literal(AuthMethod.EIP1271)
}),
import_zod3.z.object({
method: import_zod3.z.literal(AuthMethod.EOA)
}),
import_zod3.z.object({
method: import_zod3.z.literal(AuthMethod.KeyPair)
})
])
);
var AuthenticationSchema = import_zod3.z.object({
params: AuthenticationParamsSchema,
sig: import_zod3.z.string()
});
// schemas/contact.ts
var import_zod4 = require("zod");
var options = {
EMAIL: import_zod4.z.object({ type: import_zod4.z.literal("EMAIL"), contact: import_zod4.z.string().email() }),
TELEGRAM: import_zod4.z.object({ type: import_zod4.z.literal("TELEGRAM"), contact: import_zod4.z.string() })
// So we don't forget to update here in case ContactType changes
};
var GuildContactCreationPayloadSchema = import_zod4.z.discriminatedUnion("type", [
options.EMAIL,
options.TELEGRAM
]);
var GuildContactUpdatePayloadSchema = GuildContactCreationPayloadSchema;
// schemas/dynamicReward.ts
var import_zod5 = require("zod");
var InputSourceSchema = import_zod5.z.discriminatedUnion("type", [
import_zod5.z.object({
type: import_zod5.z.literal("REQUIREMENT_AMOUNT"),
roleId: PositiveInteger,
requirementId: PositiveInteger
}),
import_zod5.z.object({
type: import_zod5.z.literal("REQUIREMENT_ACCESS"),
roleId: PositiveInteger,
requirementId: PositiveInteger,
value: import_zod5.z.number().default(1)
}),
import_zod5.z.object({
type: import_zod5.z.literal("POINTS"),
guildId: PositiveInteger,
guildPlatformId: PositiveInteger
}),
import_zod5.z.object({
type: import_zod5.z.literal("STATIC"),
value: PositiveInteger
})
]);
var Linear = import_zod5.z.object({
type: import_zod5.z.literal("LINEAR"),
params: import_zod5.z.object({
multiplier: import_zod5.z.number().default(1),
addition: import_zod5.z.number().default(0),
shouldFloorResult: import_zod5.z.boolean().default(false).optional()
}).default({}),
input: InputSourceSchema.or(import_zod5.z.tuple([InputSourceSchema])).transform(
(_) => Array.isArray(_) ? _ : [_]
)
});
var DummyMultiInput = import_zod5.z.object({
type: import_zod5.z.literal("SUM"),
input: import_zod5.z.array(InputSourceSchema)
});
var DynamicRewardOperation = import_zod5.z.discriminatedUnion("type", [
Linear,
DummyMultiInput
]);
var DynamicAmountSchema = import_zod5.z.object({
operation: DynamicRewardOperation
});
// schemas/form.ts
var import_zod6 = require("zod");
var FieldBaseSchema = import_zod6.z.object({
id: import_zod6.z.string().uuid().optional(),
question: import_zod6.z.string().min(1),
isRequired: import_zod6.z.boolean().optional().default(false)
});
var TextAndNumberFieldSchema = FieldBaseSchema.extend({
type: import_zod6.z.enum(["SHORT_TEXT", "LONG_TEXT", "NUMBER"])
});
var OptionsSchema = import_zod6.z.object({
options: import_zod6.z.array(import_zod6.z.string().or(import_zod6.z.number()))
});
var SingleAndMultipleChoiceFieldSchema = FieldBaseSchema.merge(
OptionsSchema
).extend({
type: import_zod6.z.enum(["SINGLE_CHOICE", "MULTIPLE_CHOICE"]),
allowOther: import_zod6.z.boolean().optional().default(false)
});
var RateFieldSchema = FieldBaseSchema.merge(OptionsSchema).extend({
type: import_zod6.z.enum(["RATE"]),
worstLabel: import_zod6.z.string().optional(),
bestLabel: import_zod6.z.string().optional()
});
var FieldCreationPayloadSchema = import_zod6.z.discriminatedUnion("type", [
TextAndNumberFieldSchema,
SingleAndMultipleChoiceFieldSchema,
RateFieldSchema
]);
var FieldSchema = FieldCreationPayloadSchema.and(
import_zod6.z.object({
id: import_zod6.z.string().uuid().optional()
})
);
var FormCreationPayloadSchema = import_zod6.z.object({
name: import_zod6.z.string().min(1),
description: import_zod6.z.string().max(2e3).optional(),
isEditable: import_zod6.z.boolean().optional().default(false),
fields: import_zod6.z.array(FieldCreationPayloadSchema)
});
var FormSchema = FormCreationPayloadSchema.extend({
id: import_zod6.z.number(),
creatorUserId: import_zod6.z.number().nullable(),
guildId: import_zod6.z.number(),
fields: import_zod6.z.array(FieldSchema),
submissionCount: import_zod6.z.number().optional(),
createdAt: DateLike,
updatedAt: DateLike
}).nullable();
var SubmissionCreationAnswerSchema = import_zod6.z.object({
fieldId: import_zod6.z.string().uuid(),
value: import_zod6.z.string().or(import_zod6.z.number()).or(import_zod6.z.array(import_zod6.z.string().or(import_zod6.z.number()))).optional().nullable().transform(
(value) => Array.isArray(value) ? JSON.stringify(value) : value
)
});
var SubmissionAnswerSchema = SubmissionCreationAnswerSchema.extend({
userSubmissionId: import_zod6.z.number(),
value: import_zod6.z.string().or(import_zod6.z.number()).optional().nullable().transform((value) => {
if (!value)
return void 0;
let parsedValue = value;
try {
parsedValue = JSON.parse(value?.toString());
} catch {
}
return parsedValue;
})
});
var UserSubmissionCreationSchema = import_zod6.z.object({
submissionAnswers: import_zod6.z.array(SubmissionCreationAnswerSchema)
});
var UserSubmissionSchema = import_zod6.z.object({
id: import_zod6.z.number(),
formId: import_zod6.z.number(),
createdAt: DateLike,
submissionAnswers: import_zod6.z.array(SubmissionAnswerSchema)
}).nullable();
var UserSubmissionsSchema = import_zod6.z.array(
import_zod6.z.object({
userId: import_zod6.z.number(),
formId: import_zod6.z.number(),
platformUsers: import_zod6.z.array(
import_zod6.z.object({
platformId: import_zod6.z.number(),
platformUserId: import_zod6.z.string(),
username: import_zod6.z.string().nullable()
})
).default([]),
addresses: import_zod6.z.array(import_zod6.z.string()),
submittedAt: import_zod6.z.date(),
submissionAnswers: import_zod6.z.array(SubmissionCreationAnswerSchema),
isShared: import_zod6.z.boolean().nullable()
})
).default([]);
// schemas/guild.ts
var import_zod41 = require("zod");
// utils.ts
var ZERO_CODE = 48;
var NINE_CODE = ZERO_CODE + 9;
var isCharNumeric = (char) => char.charCodeAt(0) >= ZERO_CODE && char.charCodeAt(0) <= NINE_CODE;
var isNumeric = (str) => [...str].every((char) => isCharNumeric(char));
var nonEmptyRefine = (message = ErrorMessages.EMPTY_OBJECT) => [
(someObject) => Object.keys(someObject).length > 0,
{ message }
];
function toTupleType(v) {
return v;
}
function createZodSafeEnumValues(arr) {
if (arr.length < 2)
throw new Error(
`zod enum safe array must have at least 2 elements, received ${arr.length}`
);
return [arr[0], ...arr.slice(1)];
}
// schemas/guildReward.ts
var import_zod7 = require("zod");
var DiscordGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("DISCORD"),
platformGuildData: import_zod7.z.object({
inviteChannel: import_zod7.z.string().optional(),
// Custom invite link, can be modified on our frontend
invite: import_zod7.z.string().optional(),
joinButton: import_zod7.z.boolean().optional(),
needCaptcha: import_zod7.z.boolean().optional(),
name: import_zod7.z.string().optional()
}).default({})
});
var TelegramGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("TELEGRAM")
});
var GitHubGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("GITHUB"),
platformGuildData: import_zod7.z.object({
// Optional, because we don't need to send it when creating a reward, but our backend will save this data here
platformUserId: import_zod7.z.number().int().optional()
}).default({})
});
var GoogleGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("GOOGLE"),
platformGuildData: import_zod7.z.object({
role: import_zod7.z.enum(["reader", "commenter", "writer"]).optional().default("reader"),
mimeType: import_zod7.z.string(),
iconLink: import_zod7.z.string()
})
});
var ContractCallGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("CONTRACT_CALL"),
platformGuildData: import_zod7.z.object({
chain: ChainSchema.extract(NFTRewardSupportedChains),
contractAddress: EvmAddressSchema,
function: import_zod7.z.enum([
"function claim(address payToken, address receiver, bytes calldata signature) payable",
"function claim(uint256 amount, address receiver, uint256 userId, uint256 signedAt, bytes calldata signature) payable"
]),
argsToSign: import_zod7.z.array(import_zod7.z.string()),
name: import_zod7.z.string().optional(),
symbol: import_zod7.z.string().optional(),
imageUrl: import_zod7.z.string().optional(),
description: import_zod7.z.string().optional()
})
});
var UniqueTextGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("UNIQUE_TEXT"),
platformGuildData: import_zod7.z.object({
texts: import_zod7.z.array(import_zod7.z.string()),
name: import_zod7.z.string().optional(),
imageUrl: import_zod7.z.string().optional()
})
});
var TextGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("TEXT"),
platformGuildData: import_zod7.z.object({
text: import_zod7.z.string(),
name: import_zod7.z.string().optional(),
imageUrl: import_zod7.z.string().optional()
})
});
var GuildPinGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("GUILD_PIN"),
platformGuildData: import_zod7.z.object({
pinChain: import_zod7.z.enum(
createZodSafeEnumValues(Object.values(PinSupportedChains))
),
contractAddress: AnyAddressSchema
})
});
var PointsGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("POINTS"),
platformGuildData: import_zod7.z.object({
name: import_zod7.z.string().optional(),
imageUrl: import_zod7.z.string().optional()
}).default({})
});
var PoapGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("POAP"),
platformGuildData: import_zod7.z.object({
fancyId: import_zod7.z.string(),
eventId: import_zod7.z.number(),
name: import_zod7.z.string().optional(),
imageUrl: import_zod7.z.string().optional()
})
});
var FormGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("FORM"),
platformGuildData: import_zod7.z.object({
formId: import_zod7.z.number()
})
});
var GatherTownGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("GATHER_TOWN"),
platformGuildData: import_zod7.z.object({
name: import_zod7.z.string(),
gatherSpaceId: import_zod7.z.string(),
gatherApiKey: import_zod7.z.string(),
gatherAffiliation: import_zod7.z.string(),
gatherRole: import_zod7.z.string()
})
});
var ERC20GuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("ERC20"),
platformGuildData: import_zod7.z.object({
poolId: import_zod7.z.number(),
chain: ChainSchema.extract([
"BASE_MAINNET",
"BSC",
"MANTLE",
"OPTIMISM",
"POLYGON",
"SEPOLIA"
]),
contractAddress: EvmAddressSchema,
name: import_zod7.z.string(),
imageUrl: import_zod7.z.string(),
description: import_zod7.z.string(),
tokenAddress: EvmAddressSchema
})
});
var FarcasterChannelGuildRewardSchema = import_zod7.z.object({
platformName: import_zod7.z.literal("FARCASTER_CHANNEL"),
platformGuildData: import_zod7.z.object({
moderatorUserId: PositiveInteger
})
});
var BasicGuildRewardSchema = import_zod7.z.discriminatedUnion("platformName", [
DiscordGuildRewardSchema,
TelegramGuildRewardSchema,
GitHubGuildRewardSchema,
GoogleGuildRewardSchema,
ContractCallGuildRewardSchema,
UniqueTextGuildRewardSchema,
TextGuildRewardSchema,
GuildPinGuildRewardSchema,
PointsGuildRewardSchema,
PoapGuildRewardSchema,
FormGuildRewardSchema,
GatherTownGuildRewardSchema,
ERC20GuildRewardSchema,
FarcasterChannelGuildRewardSchema
]).and(
import_zod7.z.object({
platformGuildId: import_zod7.z.string().transform(
(value) => value.includes("/") ? encodeURIComponent(value) : value
)
})
);
var GuildRewardSchema = BasicGuildRewardSchema.and(
import_zod7.z.object({
id: PositiveInteger,
// We'll probably deprecate this, left here to support older platforms too
platformGuildName: import_zod7.z.string().optional(),
// We only append the invite for the Discord reward in our DB in case there's no specified `platformGuildData.invite`
invite: import_zod7.z.string().optional(),
// In some cases we'll fetch the platform's name request-time, in that case it'll be added here
name: import_zod7.z.string().optional()
})
);
var GuildRewardCreationSchema = BasicGuildRewardSchema.and(
import_zod7.z.object({
roleIds: import_zod7.z.array(import_zod7.z.number().int().positive()).optional()
})
);
var GuildRewardUpdateSchema = import_zod7.z.object({
platformGuildData: import_zod7.z.any()
}).refine(...nonEmptyRefine(ErrorMessages.REQUIRED_PLATFORM_GUILD_DATA));
// schemas/role.ts
var import_zod40 = require("zod");
// schemas/requirement.ts
var import_zod38 = require("zod");
// schemas/requirements/alchemy.ts
var import_zod8 = require("zod");
var AlchemyChains = import_zod8.z.enum([
"ETHEREUM",
"POLYGON",
"ARBITRUM",
"OPTIMISM",
"GOERLI",
"POLYGON_MUMBAI"
]);
var EthIndexerChains = import_zod8.z.enum(["BASE_GOERLI"]);
var alchemy_default = [
import_zod8.z.object({
type: import_zod8.z.enum(["ALCHEMY_FIRST_TX", "ALCHEMY_FIRST_TX_RELATIVE"]),
chain: AlchemyChains.or(EthIndexerChains).default("ETHEREUM"),
data: import_zod8.z.object({
maxAmount: import_zod8.z.number()
})
}),
import_zod8.z.object({
type: import_zod8.z.enum([
"ALCHEMY_CONTRACT_DEPLOY",
"ALCHEMY_CONTRACT_DEPLOY_RELATIVE",
"ALCHEMY_TX_COUNT",
"ALCHEMY_TX_COUNT_RELATIVE"
]),
chain: AlchemyChains.or(EthIndexerChains).default("ETHEREUM"),
address: EvmAddressSchema.nullable().optional(),
data: import_zod8.z.object({
txCount: import_zod8.z.number(),
maxAmount: import_zod8.z.number().optional(),
minAmount: import_zod8.z.number().optional()
})
}),
import_zod8.z.object({
type: import_zod8.z.enum(["ALCHEMY_TX_VALUE", "ALCHEMY_TX_VALUE_RELATIVE"]),
chain: AlchemyChains.default("ETHEREUM"),
address: EvmAddressSchema.nullable().optional(),
data: import_zod8.z.object({
txValue: import_zod8.z.number(),
maxAmount: import_zod8.z.number().optional(),
minAmount: import_zod8.z.number().optional()
})
})
];
// schemas/requirements/allowlist.ts
var import_zod9 = require("zod");
var AllowlistSchema = import_zod9.z.object({
addresses: import_zod9.z.array(AnyAddressSchema).default([]),
fileId: import_zod9.z.string().min(1).optional(),
hideAllowlist: import_zod9.z.boolean().optional()
}).default({});
var allowlist_default = [
import_zod9.z.object({
type: import_zod9.z.literal("ALLOWLIST"),
data: AllowlistSchema
}),
import_zod9.z.object({
type: import_zod9.z.literal("ALLOWLIST_EMAIL"),
data: import_zod9.z.object({
addresses: import_zod9.z.array(import_zod9.z.string().email().toLowerCase()).default([]),
hideAllowlist: import_zod9.z.boolean().optional(),
fileId: import_zod9.z.string().min(1).optional()
}).default({})
})
];
// schemas/requirements/captcha.ts
var import_zod10 = require("zod");
var captcha_default = import_zod10.z.object({
type: import_zod10.z.literal("CAPTCHA"),
data: import_zod10.z.object({
maxAmount: import_zod10.z.number().int().nonnegative().optional()
}).default({})
});
// schemas/requirements/coin.ts
var import_zod11 = require("zod");
var coin_default = import_zod11.z.object({
type: import_zod11.z.literal("COIN"),
chain: ChainSchema,
data: import_zod11.z.object({
minAmount: import_zod11.z.number(),
maxAmount: import_zod11.z.number().optional()
})
});
// schemas/requirements/contract.ts
var import_zod12 = require("zod");
var contract_default = import_zod12.z.object({
type: import_zod12.z.literal("CONTRACT"),
data: import_zod12.z.object({
id: import_zod12.z.string().trim().min(1),
resultIndex: import_zod12.z.number().int().nonnegative().optional(),
params: import_zod12.z.array(import_zod12.z.string().or(import_zod12.z.number()).or(import_zod12.z.boolean())),
resultMatch: import_zod12.z.enum(["=", ">", "<", ">=", "<="]),
expected: import_zod12.z.string()
}),
address: EvmAddressSchema,
chain: ChainSchema
});
// schemas/requirements/covalent.ts
var import_zod13 = require("zod");
var CovalentChains = import_zod13.z.enum([
"ETHEREUM",
"SCROLL_ALPHA",
"POLYGON",
"BASE_MAINNET",
"BASE_GOERLI",
"ZORA",
"AVALANCHE",
"ZKSYNC_ERA",
"POLYGON_ZKEVM",
"CRONOS",
"NEON_EVM",
"PGN",
"OPTIMISM",
"LINEA",
"MANTLE",
"SCROLL",
"SCROLL_SEPOLIA",
"RONIN",
"ARBITRUM",
"METIS",
"TAIKO_KATLA",
"BSC",
"BASE_SEPOLIA",
"OASIS_SAPPHIRE",
"BLAST_MAINNET",
"ZETACHAIN",
"TAIKO",
"FANTOM",
"SEI",
"ROOTSTOCK",
"MODE",
"LISK",
"CRONOS_ZKEVM",
"INK",
"INK_SEPOLIA",
"IOTA",
"SONIC",
"SOPHON",
"ZERO",
"FORM",
"XDC",
"SONEIUM"
]);
var Timestamps = import_zod13.z.object({
minAmount: import_zod13.z.number(),
maxAmount: import_zod13.z.number()
}).partial().default({});
var methodInput = import_zod13.z.object({
index: import_zod13.z.number().int().nonnegative(),
value: import_zod13.z.string(),
operator: import_zod13.z.enum([
"equal",
"not_equal",
"greater",
"greater_or_equal",
"less",
"less_or_equal",
"array_last_equal"
])
});
var covalent_default = [
import_zod13.z.object({
type: import_zod13.z.enum(["COVALENT_FIRST_TX", "COVALENT_FIRST_TX_RELATIVE"]),
chain: CovalentChains.default("ETHEREUM"),
data: import_zod13.z.object({
timestamps: Timestamps
}).default({})
}),
import_zod13.z.object({
type: import_zod13.z.enum([
"COVALENT_CONTRACT_DEPLOY",
"COVALENT_CONTRACT_DEPLOY_RELATIVE",
"COVALENT_TX_COUNT",
"COVALENT_TX_COUNT_RELATIVE"
]),
chain: CovalentChains.default("ETHEREUM"),
address: EvmAddressSchema.nullable().optional(),
data: import_zod13.z.object({
txCount: import_zod13.z.number().int().nonnegative(),
maxAmount: import_zod13.z.number().optional(),
minAmount: import_zod13.z.number().optional(),
timestamps: Timestamps
})
}),
import_zod13.z.object({
type: import_zod13.z.enum(["COVALENT_TX_VALUE", "COVALENT_TX_VALUE_RELATIVE"]),
chain: CovalentChains.default("ETHEREUM"),
address: EvmAddressSchema.nullable().optional(),
data: import_zod13.z.object({
txValue: import_zod13.z.number(),
maxAmount: import_zod13.z.number().optional(),
minAmount: import_zod13.z.number().optional(),
timestamps: Timestamps
})
}),
import_zod13.z.object({
type: import_zod13.z.enum([
"COVALENT_CONTRACT_CALL_COUNT",
"COVALENT_CONTRACT_CALL_COUNT_RELATIVE"
]),
chain: CovalentChains.extract(["INK", "INK_SEPOLIA", "SONIC"]).default(
"INK"
),
address: EvmAddressSchema,
data: import_zod13.z.object({
method: import_zod13.z.string(),
inputs: import_zod13.z.array(methodInput).default([]),
txCount: import_zod13.z.number(),
timestamps: Timestamps,
maxAmount: import_zod13.z.number().optional(),
minAmount: import_zod13.z.number().optional()
}).refine(
({ method, inputs }) => !method.startsWith("0x") || !inputs?.length,
{
message: "Cannot define inputs if method is defined as a raw byte signature"
}
)
})
];
// schemas/requirements/discord.ts
var import_zod14 = require("zod");
var discord_default = [
import_zod14.z.object({
type: import_zod14.z.literal("DISCORD_ROLE"),
data: import_zod14.z.object({
serverId: import_zod14.z.string().min(1),
roleId: import_zod14.z.string().min(1),
serverName: import_zod14.z.string().min(1).optional(),
roleName: import_zod14.z.string().min(1).optional()
})
}),
import_zod14.z.object({
type: import_zod14.z.enum(["DISCORD_JOIN", "DISCORD_JOIN_FROM_NOW"]),
data: import_zod14.z.object({
memberSince: import_zod14.z.number()
// fromNow: z.boolean().optional(),
})
}),
import_zod14.z.object({
type: import_zod14.z.literal("DISCORD_MEMBER_SINCE"),
data: import_zod14.z.object({
serverId: import_zod14.z.string().min(1),
serverName: import_zod14.z.string().min(1).optional(),
memberSince: import_zod14.z.number().optional()
})
})
];
// schemas/requirements/eas.ts
var import_zod15 = require("zod");
var EasChains = import_zod15.z.enum([
"ETHEREUM",
"OPTIMISM",
"ARBITRUM",
"SEPOLIA",
"BASE_GOERLI",
"BASE_MAINNET",
"BASE_SEPOLIA",
"LINEA"
]);
var EasCommonFields = import_zod15.z.object({
schemaId: import_zod15.z.string().min(1)
}).and(
import_zod15.z.object({ key: import_zod15.z.string().min(1), val: import_zod15.z.string().min(1) }).or(
import_zod15.z.object({
key: import_zod15.z.undefined().or(import_zod15.z.literal("")),
val: import_zod15.z.undefined().or(import_zod15.z.literal(""))
}).transform(() => ({ key: void 0, val: void 0 }))
)
);
var eas_default = [
import_zod15.z.object({
type: import_zod15.z.enum(["EAS_ATTESTED_BY", "COINBASE_EAS_ATTESTED_BY"]),
chain: EasChains.default("ETHEREUM"),
data: EasCommonFields.and(
import_zod15.z.object({
attester: EvmAddressSchema
})
)
}),
import_zod15.z.object({
chain: EasChains.default("ETHEREUM"),
type: import_zod15.z.literal("EAS_ATTEST"),
data: EasCommonFields.and(
import_zod15.z.object({
recipient: EvmAddressSchema
})
)
})
];
// schemas/requirements/email.ts
var import_zod16 = require("zod");
var email_default = [
import_zod16.z.object({
type: import_zod16.z.literal("EMAIL_DOMAIN"),
data: import_zod16.z.object({
domain: import_zod16.z.string().toLowerCase()
})
}),
import_zod16.z.object({
type: import_zod16.z.literal("EMAIL_VERIFIED"),
data: import_zod16.z.object({}).default({})
})
];
// schemas/requirements/farcaster.ts
var import_zod17 = require("zod");
var FarcasterLikeOrRecast = import_zod17.z.object({
type: import_zod17.z.enum(["FARCASTER_LIKE", "FARCASTER_RECAST"]),
data: import_zod17.z.object({
hash: import_zod17.z.string().min(1),
url: import_zod17.z.undefined()
}).or(
import_zod17.z.object({
url: import_zod17.z.string().url(),
hash: import_zod17.z.undefined()
})
)
// z
// .object({
// hash: z.string(),
// url: z.string().url(),
// })
// .partial()
// .refine((val) => Object.keys(val).length === 1, {
// message: "Please specify either a url, or a hash",
// })
// .transform(
// (val) =>
// val as { hash: string; url: never } | { url: string; hash: never }
// ),
});
var FarcasterFollow = import_zod17.z.object({
type: import_zod17.z.enum(["FARCASTER_FOLLOW", "FARCASTER_FOLLOWED_BY"]),
data: import_zod17.z.object({
id: import_zod17.z.number()
})
});
var FarcasterStringId = import_zod17.z.object({
type: import_zod17.z.enum([
"FARCASTER_FOLLOW_CHANNEL",
"FARCASTER_USERNAME",
"FARCASTER_BIO"
]),
data: import_zod17.z.object({
id: import_zod17.z.string().min(1)
})
});
var FarcasterTotalFollowers = import_zod17.z.object({
type: import_zod17.z.literal("FARCASTER_TOTAL_FOLLOWERS"),
data: import_zod17.z.object({
min: import_zod17.z.number().int()
})
});
var FarcasterProfile = import_zod17.z.object({
type: import_zod17.z.literal("FARCASTER_PROFILE"),
data: import_zod17.z.object({}).default({})
});
var farcaster_default = [
FarcasterProfile,
FarcasterFollow,
FarcasterLikeOrRecast,
FarcasterTotalFollowers,
FarcasterStringId
];
// schemas/requirements/form.ts
var import_zod18 = require("zod");
var FormSubmissionDetailedAnswerSchema = import_zod18.z.object({
fieldId: import_zod18.z.string()
});
var FormSubmissionDetailedGeneralAnswerSchema = FormSubmissionDetailedAnswerSchema.extend({
value: import_zod18.z.string().or(import_zod18.z.number())
}).strict();
var FormSubmissionDetailedRateAnswerSchema = FormSubmissionDetailedAnswerSchema.and(
import_zod18.z.object({
minAmount: import_zod18.z.number().int().positive().or(import_zod18.z.string().pipe(import_zod18.z.coerce.number())).optional(),
maxAmount: import_zod18.z.number().int().positive().or(import_zod18.z.string().pipe(import_zod18.z.coerce.number())).optional()
}).refine(...nonEmptyRefine("Invalid value for minAmount/maxAmount"))
);
var FormSubmissionDetailedMultipleChoiceAnswerSchema = FormSubmissionDetailedAnswerSchema.and(
import_zod18.z.object({
acceptedAnswers: import_zod18.z.array(import_zod18.z.string()).optional(),
rejectedAnswers: import_zod18.z.array(import_zod18.z.string()).optional()
}).refine(
...nonEmptyRefine("Invalid value for acceptedAnswers/rejectedAnswers")
)
);
var FormSubmissionSchema = import_zod18.z.object({
id: import_zod18.z.number().int().positive(),
guildId: import_zod18.z.number().int().positive(),
answers: import_zod18.z.array(
import_zod18.z.union([
FormSubmissionDetailedGeneralAnswerSchema,
FormSubmissionDetailedRateAnswerSchema,
FormSubmissionDetailedMultipleChoiceAnswerSchema
])
).optional()
});
var form_default = [
import_zod18.z.object({
type: import_zod18.z.literal("FORM_SUBMISSION"),
data: FormSubmissionSchema
}),
import_zod18.z.object({
type: import_zod18.z.literal("FORM_APPROVAL"),
data: AllowlistSchema
})
];
// schemas/requirements/free.ts
var import_zod19 = require("zod");
var free_default = import_zod19.z.object({
type: import_zod19.z.literal("FREE"),
data: import_zod19.z.object({}).default({})
});
// schemas/requirements/fuel.ts
var import_zod20 = require("zod");
var fuel_default = [
import_zod20.z.object({
type: import_zod20.z.literal("FUEL_BALANCE"),
data: import_zod20.z.object({
minAmount: import_zod20.z.number(),
maxAmount: import_zod20.z.number().optional()
})
}),
import_zod20.z.object({
type: import_zod20.z.literal("FUEL_TRANSACTIONS"),
data: import_zod20.z.object({
id: import_zod20.z.enum(["script", "mint", "create"]).optional(),
minAmount: import_zod20.z.number().int().optional(),
maxAmount: import_zod20.z.number().int().optional()
})
})
];
// schemas/requirements/galaxy.ts
var import_zod21 = require("zod");
var galaxy_default = import_zod21.z.object({
type: import_zod21.z.enum(["GALAXY", "GALAXY_PARTICIPATION"]),
data: import_zod21.z.object({
galaxyId: import_zod21.z.string().min(1)
})
});
// schemas/requirements/gitcoin.ts
var import_zod22 = require("zod");
var gitcoin_default = [
import_zod22.z.object({
type: import_zod22.z.literal("GITCOIN_PASS"),
data: import_zod22.z.object({}).default({})
}),
import_zod22.z.object({
type: import_zod22.z.literal("GITCOIN_STAMP"),
data: import_zod22.z.object({
stamp: import_zod22.z.string(),
minAmount: import_zod22.z.number(),
maxAmount: import_zod22.z.number(),
credType: import_zod22.z.string(),
issuer: import_zod22.z.string()
}).partial().default({})
}),
import_zod22.z.object({
type: import_zod22.z.literal("GITCOIN_SCORE"),
data: import_zod22.z.object({
id: import_zod22.z.string().min(1),
score: import_zod22.z.number()
})
})
];
// schemas/requirements/github.ts
var import_zod23 = require("zod");
var GithubStarringSchema = import_zod23.z.object({
type: import_zod23.z.literal("GITHUB_STARRING"),
data: import_zod23.z.object({
id: import_zod23.z.string().url()
})
});
var GithubAccountAgeSchema = import_zod23.z.object({
type: import_zod23.z.enum(["GITHUB_ACCOUNT_AGE", "GITHUB_ACCOUNT_AGE_RELATIVE"]),
data: import_zod23.z.object({
minAmount: import_zod23.z.number().int().positive().optional(),
maxAmount: import_zod23.z.number().int().positive().optional()
}).default({})
});
var GithubCommitCountSchema = import_zod23.z.object({
type: import_zod23.z.enum(["GITHUB_COMMIT_COUNT", "GITHUB_COMMIT_COUNT_RELATIVE"]),
data: import_zod23.z.object({
id: import_zod23.z.number().int().positive(),
minAmount: import_zod23.z.number().int().positive().optional(),
maxAmount: import_zod23.z.number().int().positive().optional()
})
});
var github_default = [
GithubStarringSchema,
GithubAccountAgeSchema,
GithubCommitCountSchema
];
// schemas/requirements/guild.ts
var import_zod24 = require("zod");
var guild_default = [
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_MEMBER"),
data: import_zod24.z.object({
guildId: import_zod24.z.number().int().positive()
})
}),
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_ROLE"),
data: import_zod24.z.object({
guildId: import_zod24.z.number().int().positive(),
roleId: import_zod24.z.number().int().positive(),
minAmount: import_zod24.z.number().int().positive().optional(),
maxAmount: import_zod24.z.number().int().positive().optional()
})
}),
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_ROLE_RELATIVE"),
data: import_zod24.z.object({
guildId: import_zod24.z.number().int().positive(),
roleId: import_zod24.z.number().int().positive(),
minAmount: import_zod24.z.number().int().positive().optional(),
maxAmount: import_zod24.z.number().int().positive().optional()
})
}),
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_ADMIN"),
data: import_zod24.z.object({
minAmount: import_zod24.z.number().int().nonnegative()
})
}),
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_USER_SINCE"),
data: import_zod24.z.object({
creationDate: import_zod24.z.coerce.date().or(import_zod24.z.number()).or(import_zod24.z.string()).pipe(import_zod24.z.coerce.date())
})
}),
import_zod24.z.object({
type: import_zod24.z.literal("GUILD_MINGUILDS"),
data: import_zod24.z.object({
minAmount: import_zod24.z.number().int().positive()
})
})
];
// schemas/requirements/guildSnapshot.ts
var import_zod25 = require("zod");
var Snapshot = import_zod25.z.array(
import_zod25.z.object({
key: import_zod25.z.string().min(1).toLowerCase(),
value: import_zod25.z.number()
})
);
var SnapshotRequirementData = import_zod25.z.object({
snapshot: Snapshot.default([]),
fileId: import_zod25.z.string().min(1).optional(),
isHidden: import_zod25.z.boolean().default(false),
guildPlatformId: PositiveInteger.optional()
}).default({});
var AddressSnapshot = import_zod25.z.object({
type: import_zod25.z.literal("GUILD_SNAPSHOT"),
data: SnapshotRequirementData
});
var guildSnapshot_default = [AddressSnapshot];
// schemas/requirements/jumper.ts
var import_zod26 = require("zod");
var JumperLevelSchema = import_zod26.z.object({
type: import_zod26.z.literal("JUMPER_LEVEL"),
data: import_zod26.z.object({
minAmount: PositiveInteger
})
});
var JumperRewardTypeSchema = import_zod26.z.object({
type: import_zod26.z.literal("JUMPER_TYPE"),
data: impo