@awarizon/sdk 2.0.0

package/dist/index.js

@@ -0,0 +1,1154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AlreadyDelegatedError: () => AlreadyDelegatedError,
+  AwarizonClient: () => AwarizonClient,
+  AwarizonError: () => AwarizonError,
+  BLOCK_TIME_SECONDS: () => BLOCK_TIME_SECONDS,
+  CHAIN_NAME: () => CHAIN_NAME,
+  CampaignDeliveryLimitReachedError: () => CampaignDeliveryLimitReachedError,
+  CampaignExpiredError: () => CampaignExpiredError,
+  CampaignNotActiveError: () => CampaignNotActiveError,
+  CampaignNotFoundError: () => CampaignNotFoundError,
+  CannotDelegateToSelfError: () => CannotDelegateToSelfError,
+  CountryCapExceededError: () => CountryCapExceededError,
+  DEFAULT_CAMPAIGN_DURATION_DAYS: () => DEFAULT_CAMPAIGN_DURATION_DAYS,
+  DEFAULT_ENDPOINT: () => DEFAULT_ENDPOINT,
+  DEVELOPER_MIN_TENURE_DAYS: () => DEVELOPER_MIN_TENURE_DAYS,
+  DelegationNotFoundError: () => DelegationNotFoundError,
+  DeveloperAlreadyRegisteredError: () => DeveloperAlreadyRegisteredError,
+  DeveloperNotFoundError: () => DeveloperNotFoundError,
+  DeveloperNotVerifiedError: () => DeveloperNotVerifiedError,
+  DeveloperSuspendedError: () => DeveloperSuspendedError,
+  ENGAGEMENT_COOLDOWN_HOURS: () => ENGAGEMENT_COOLDOWN_HOURS,
+  EPOCH_LENGTH_BLOCKS: () => EPOCH_LENGTH_BLOCKS,
+  EngagementCooldownActiveError: () => EngagementCooldownActiveError,
+  EngagementDailyLimitReachedError: () => EngagementDailyLimitReachedError,
+  EngagementInvalidError: () => EngagementInvalidError,
+  EpochNotReadyError: () => EpochNotReadyError,
+  GENESIS_VALIDATORS: () => GENESIS_VALIDATORS,
+  InboxAlreadyDeliveredError: () => InboxAlreadyDeliveredError,
+  InboxFullError: () => InboxFullError,
+  InboxRecordNotFoundError: () => InboxRecordNotFoundError,
+  InsufficientBalanceError: () => InsufficientBalanceError,
+  InsufficientStakeError: () => InsufficientStakeError,
+  InvalidCampaignIdError: () => InvalidCampaignIdError,
+  InvalidManifestHashError: () => InvalidManifestHashError,
+  MAX_CAMPAIGN_DURATION_DAYS: () => MAX_CAMPAIGN_DURATION_DAYS,
+  MAX_CATEGORY_HISTORY_ENTRIES: () => MAX_CATEGORY_HISTORY_ENTRIES,
+  MAX_ENGAGEMENT_EVENTS_PER_DAY: () => MAX_ENGAGEMENT_EVENTS_PER_DAY,
+  MAX_REGION_CODES_PER_CAMPAIGN: () => MAX_REGION_CODES_PER_CAMPAIGN,
+  MAX_TARGETING_DIMENSIONS: () => MAX_TARGETING_DIMENSIONS,
+  MICRO_RIZ: () => MICRO_RIZ,
+  MILLI_RIZ: () => MILLI_RIZ,
+  MIN_CAMPAIGN_DURATION_DAYS: () => MIN_CAMPAIGN_DURATION_DAYS,
+  MIN_INTERACTIONS: () => MIN_INTERACTIONS,
+  MIN_SESSION_SECONDS: () => MIN_SESSION_SECONDS,
+  ManifestAlreadyRegisteredError: () => ManifestAlreadyRegisteredError,
+  ManifestLimitReachedError: () => ManifestLimitReachedError,
+  ManifestNotFoundError: () => ManifestNotFoundError,
+  MaxValidatorsReachedError: () => MaxValidatorsReachedError,
+  NotExpiredYetError: () => NotExpiredYetError,
+  PERF_WEIGHT_BLOCKS_BPS: () => PERF_WEIGHT_BLOCKS_BPS,
+  PERF_WEIGHT_FINALITY_BPS: () => PERF_WEIGHT_FINALITY_BPS,
+  PERF_WEIGHT_SLASH_BPS: () => PERF_WEIGHT_SLASH_BPS,
+  PERF_WEIGHT_UPTIME_BPS: () => PERF_WEIGHT_UPTIME_BPS,
+  PLANCK: () => PLANCK,
+  RIZ: () => RIZ,
+  RegionCapExceededError: () => RegionCapExceededError,
+  ResetNotReadyError: () => ResetNotReadyError,
+  TARGET_VALIDATORS: () => TARGET_VALIDATORS,
+  TargetingDimensionLimitExceededError: () => TargetingDimensionLimitExceededError,
+  UnauthorizedError: () => UnauthorizedError,
+  ValidatorAlreadyRegisteredError: () => ValidatorAlreadyRegisteredError,
+  ValidatorNotActiveError: () => ValidatorNotActiveError,
+  ValidatorNotFoundError: () => ValidatorNotFoundError,
+  aliceKeypair: () => aliceKeypair,
+  awarizonRpc: () => awarizonRpc,
+  awarizonTypes: () => awarizonTypes,
+  blocksToTime: () => blocksToTime,
+  bobKeypair: () => bobKeypair,
+  buildAdvanceEpoch: () => buildAdvanceEpoch,
+  buildBloomFilter: () => buildBloomFilter,
+  buildCheckWalletMatch: () => buildCheckWalletMatch,
+  buildClaimReward: () => buildClaimReward,
+  buildCreateAsset: () => buildCreateAsset,
+  buildCreateCampaign: () => buildCreateCampaign,
+  buildDelegateStake: () => buildDelegateStake,
+  buildDeliverToInbox: () => buildDeliverToInbox,
+  buildDismissInboxRecord: () => buildDismissInboxRecord,
+  buildExpireCampaign: () => buildExpireCampaign,
+  buildMintAsset: () => buildMintAsset,
+  buildRegisterDeveloper: () => buildRegisterDeveloper,
+  buildRegisterManifest: () => buildRegisterManifest,
+  buildRegisterValidator: () => buildRegisterValidator,
+  buildResetDailyEngagement: () => buildResetDailyEngagement,
+  buildRunEpochElection: () => buildRunEpochElection,
+  buildRunTargetingBatch: () => buildRunTargetingBatch,
+  buildSlashValidator: () => buildSlashValidator,
+  buildStakeRiz: () => buildStakeRiz,
+  buildSubmitEngagement: () => buildSubmitEngagement,
+  buildTerminateCampaign: () => buildTerminateCampaign,
+  buildTransferAsset: () => buildTransferAsset,
+  buildUndelegateStake: () => buildUndelegateStake,
+  buildUpdatePerformance: () => buildUpdatePerformance,
+  buildUpdateWalletIndex: () => buildUpdateWalletIndex,
+  bytesToHex: () => bytesToHex,
+  checkCampaignMatch: () => checkCampaignMatch,
+  connect: () => connect,
+  createKeyring: () => createKeyring,
+  formatRiz: () => formatRiz,
+  generateCampaignId: () => generateCampaignId,
+  getActiveCampaignCount: () => getActiveCampaignCount,
+  getActiveValidators: () => getActiveValidators,
+  getBlockTransactions: () => getBlockTransactions,
+  getCampaign: () => getCampaign,
+  getCampaignDeliveryStatus: () => getCampaignDeliveryStatus,
+  getDeveloperCampaigns: () => getDeveloperCampaigns,
+  getDeveloperManifests: () => getDeveloperManifests,
+  getDeveloperProfile: () => getDeveloperProfile,
+  getIdentity: () => getIdentity,
+  getInboxCount: () => getInboxCount,
+  getInboxRecord: () => getInboxRecord,
+  getLinkedAddresses: () => getLinkedAddresses,
+  getNetworkStats: () => getNetworkStats,
+  getRecentTransactions: () => getRecentTransactions,
+  getTokenStats: () => getTokenStats,
+  getTotalIdentities: () => getTotalIdentities,
+  getValidatorCount: () => getValidatorCount,
+  getValidatorPerformance: () => getValidatorPerformance,
+  getVestingSchedule: () => getVestingSchedule,
+  getWalletTargetingProfile: () => getWalletTargetingProfile,
+  hexToBytes: () => hexToBytes,
+  isNameAvailable: () => isNameAvailable,
+  isValidAddress: () => isValidAddress,
+  keypairFromMnemonic: () => keypairFromMnemonic,
+  keypairFromSeed: () => keypairFromSeed,
+  lookupName: () => lookupName,
+  parseChainError: () => parseChainError,
+  parsePlanckString: () => parsePlanckString,
+  parseRiz: () => parseRiz,
+  signAndSend: () => signAndSend
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_api = require("@polkadot/api");
+
+// src/customTypes.ts
+var awarizonTypes = {
+  // pallets/awarizon-types/src/lib.rs — enum AppCategory
+  AppCategory: {
+    _enum: [
+      "DeFi",
+      "Gaming",
+      "Social",
+      "Productivity",
+      "Infrastructure",
+      "DigitalAssets",
+      "DeveloperTools",
+      "Education"
+    ]
+  },
+  // pallets/awarizon-types/src/lib.rs — enum CampaignStatus
+  CampaignStatus: {
+    _enum: ["Pending", "Active", "Expired", "Terminated"]
+  },
+  // pallets/awarizon-types/src/lib.rs — enum InboxRecordStatus
+  InboxRecordStatus: {
+    _enum: ["Pending", "Delivered", "Dismissed", "Engaged"]
+  },
+  // pallets/awarizon-types/src/lib.rs — enum DeveloperStatus
+  DeveloperStatus: {
+    _enum: ["Unverified", "Verified", "Suspended"]
+  },
+  // pallets/awarizon-types/src/lib.rs — enum TransactionType
+  TransactionType: {
+    _enum: ["Financial", "Distribution", "System"]
+  },
+  // pallets/awarizon-types/src/lib.rs — struct TargetingCriteria
+  TargetingCriteria: {
+    wallet_age_min: "Option<u32>",
+    wallet_age_max: "Option<u32>",
+    riz_balance_min: "Option<u128>",
+    riz_balance_max: "Option<u128>",
+    activity_min: "Option<u32>",
+    activity_max: "Option<u32>",
+    region_codes: "Vec<u8>",
+    category_history: "Vec<AppCategory>",
+    custom_logic_hash: "Option<H256>"
+  },
+  // pallets/awarizon-types/src/lib.rs — struct DeveloperProfile<AccountId, BlockNumber>
+  DeveloperProfile: {
+    account: "AccountId",
+    staked_riz: "u128",
+    status: "DeveloperStatus",
+    first_distribution_block: "Option<u32>",
+    violation_count: "u32",
+    total_campaigns: "u32",
+    total_deliveries: "u64"
+  },
+  // pallets/awarizon-types/src/lib.rs — struct AppManifest<AccountId, BlockNumber>
+  AppManifest: {
+    manifest_hash: "H256",
+    developer: "AccountId",
+    category: "AppCategory",
+    registered_at: "u32",
+    metadata_uri: "Vec<u8>"
+  },
+  // pallets/awarizon-types/src/lib.rs — struct Campaign<AccountId, BlockNumber>
+  Campaign: {
+    campaign_id: "H256",
+    developer: "AccountId",
+    manifest_hash: "H256",
+    targeting: "TargetingCriteria",
+    status: "CampaignStatus",
+    created_at: "u32",
+    expires_at: "u32",
+    max_deliveries: "u64",
+    current_deliveries: "u64",
+    storage_fee_paid: "u128"
+  },
+  // pallets/awarizon-types/src/lib.rs — struct InboxRecord<AccountId, BlockNumber>
+  InboxRecord: {
+    record_id: "H256",
+    campaign_id: "H256",
+    developer: "AccountId",
+    manifest_hash: "H256",
+    category: "AppCategory",
+    status: "InboxRecordStatus",
+    delivered_at: "u32",
+    engaged_at: "Option<u32>",
+    reward_claimed: "bool"
+  },
+  // pallets/awarizon-consensus/src/lib.rs — struct ValidatorInfo<AccountId>
+  ValidatorInfo: {
+    account: "AccountId",
+    self_stake: "u128",
+    delegated_stake: "u128",
+    region_code: "u8",
+    country_code: "u8",
+    uptime_bps: "u32",
+    finality_bps: "u32",
+    blocks_bps: "u32",
+    slash_count: "u32",
+    is_active: "bool",
+    epoch_registered: "u64"
+  },
+  // pallets/awarizon-consensus/src/lib.rs — struct Delegation<AccountId>
+  Delegation: {
+    delegator: "AccountId",
+    validator: "AccountId",
+    amount: "u128",
+    epoch_delegated: "u64"
+  }
+};
+var awarizonRpc = {
+  awarizon: {
+    // Developer endpoints
+    getDeveloperProfile: {
+      description: "Get developer profile by SS58 account address",
+      params: [{ name: "account", type: "Text" }],
+      type: "Json"
+    },
+    getDeveloperCampaigns: {
+      description: "Get all campaign IDs for a developer",
+      params: [{ name: "account", type: "Text" }],
+      type: "Vec<Text>"
+    },
+    getDeveloperManifests: {
+      description: "Get all manifest hashes for a developer",
+      params: [{ name: "account", type: "Text" }],
+      type: "Vec<Text>"
+    },
+    // Campaign endpoints
+    getCampaign: {
+      description: "Get campaign details by campaign ID (0x hex)",
+      params: [{ name: "campaign_id", type: "Text" }],
+      type: "Json"
+    },
+    getActiveCampaignCount: {
+      description: "Get the number of currently active campaigns",
+      params: [],
+      type: "u64"
+    },
+    getCampaignDeliveryStatus: {
+      description: "Get delivery progress for a campaign",
+      params: [{ name: "campaign_id", type: "Text" }],
+      type: "Json"
+    },
+    // Inbox endpoints
+    getInboxCount: {
+      description: "Get number of inbox records for a wallet",
+      params: [{ name: "wallet", type: "Text" }],
+      type: "u32"
+    },
+    getInboxRecord: {
+      description: "Get a specific inbox record by wallet and record ID",
+      params: [
+        { name: "wallet", type: "Text" },
+        { name: "record_id", type: "Text" }
+      ],
+      type: "Json"
+    },
+    // Targeting endpoints
+    getWalletTargetingProfile: {
+      description: "Get pre-computed targeting profile for a wallet",
+      params: [{ name: "wallet", type: "Text" }],
+      type: "Json"
+    },
+    checkCampaignMatch: {
+      description: "Check cached targeting match result for (campaign, wallet)",
+      params: [
+        { name: "campaign_id", type: "Text" },
+        { name: "wallet", type: "Text" }
+      ],
+      type: "bool"
+    },
+    // Validator endpoints
+    getActiveValidators: {
+      description: "Get SS58 addresses of all active validators",
+      params: [],
+      type: "Vec<Text>"
+    },
+    getValidatorCount: {
+      description: "Get total number of active validators",
+      params: [],
+      type: "u32"
+    },
+    getValidatorPerformance: {
+      description: "Get performance metrics for a validator",
+      params: [{ name: "account", type: "Text" }],
+      type: "Json"
+    },
+    // Network stats endpoints
+    getNetworkStats: {
+      description: "Get Awarizon network statistics",
+      params: [],
+      type: "Json"
+    },
+    getTokenStats: {
+      description: "Get token issuance and engagement pool statistics",
+      params: [],
+      type: "Json"
+    }
+  }
+};
+
+// src/constants.ts
+var PLANCK = 1n;
+var RIZ = 1000000000000n;
+var MICRO_RIZ = 1000000n;
+var MILLI_RIZ = 1000000000n;
+var DEFAULT_ENDPOINT = "ws://127.0.0.1:9944";
+var CHAIN_NAME = "Awarizon Development";
+var GENESIS_VALIDATORS = 51;
+var TARGET_VALIDATORS = 121;
+var BLOCK_TIME_SECONDS = 3;
+var EPOCH_LENGTH_BLOCKS = 28800;
+var MIN_CAMPAIGN_DURATION_DAYS = 1;
+var MAX_CAMPAIGN_DURATION_DAYS = 90;
+var DEFAULT_CAMPAIGN_DURATION_DAYS = 30;
+var MIN_SESSION_SECONDS = 120;
+var MIN_INTERACTIONS = 5;
+var ENGAGEMENT_COOLDOWN_HOURS = 24;
+var MAX_ENGAGEMENT_EVENTS_PER_DAY = 10;
+var MAX_TARGETING_DIMENSIONS = 6;
+var MAX_REGION_CODES_PER_CAMPAIGN = 64;
+var MAX_CATEGORY_HISTORY_ENTRIES = 8;
+var DEVELOPER_MIN_TENURE_DAYS = 30;
+var PERF_WEIGHT_UPTIME_BPS = 5e3;
+var PERF_WEIGHT_FINALITY_BPS = 2500;
+var PERF_WEIGHT_BLOCKS_BPS = 1500;
+var PERF_WEIGHT_SLASH_BPS = 1e3;
+
+// src/client.ts
+var AwarizonClient = class {
+  constructor(endpoint = DEFAULT_ENDPOINT) {
+    this.api = null;
+    this.endpoint = endpoint;
+  }
+  async connect() {
+    if (this.api?.isConnected) return this.api;
+    const provider = new import_api.WsProvider(this.endpoint);
+    this.api = await import_api.ApiPromise.create({
+      provider,
+      types: awarizonTypes,
+      rpc: awarizonRpc
+    });
+    await this.api.isReady;
+    return this.api;
+  }
+  async disconnect() {
+    if (this.api) {
+      await this.api.disconnect();
+      this.api = null;
+    }
+  }
+  getApi() {
+    if (!this.api?.isConnected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return this.api;
+  }
+  async subscribeNewBlocks(callback) {
+    const api = this.getApi();
+    const unsub = await api.rpc.chain.subscribeNewHeads((header) => {
+      callback(header.number.toNumber(), header.hash.toHex());
+    });
+    return unsub;
+  }
+  async getBalance(address) {
+    const api = this.getApi();
+    const account = await api.query.system.account(address);
+    return BigInt(account.data.free.toString());
+  }
+};
+async function connect(endpoint = DEFAULT_ENDPOINT) {
+  const client = new AwarizonClient(endpoint);
+  await client.connect();
+  return client;
+}
+
+// src/utils.ts
+function formatRiz(planck, decimals = 4) {
+  const whole = planck / RIZ;
+  const remainder = planck % RIZ;
+  const decStr = remainder.toString().padStart(12, "0").slice(0, decimals);
+  return `${whole}.${decStr}`;
+}
+function parseRiz(riz) {
+  const [whole, decimal = ""] = riz.split(".");
+  const paddedDecimal = decimal.padEnd(12, "0").slice(0, 12);
+  return BigInt(whole) * RIZ + BigInt(paddedDecimal);
+}
+function hexToBytes(hex) {
+  const clean = hex.replace("0x", "");
+  return new Uint8Array(
+    clean.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? []
+  );
+}
+function bytesToHex(bytes) {
+  return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateCampaignId(manifestHash) {
+  const timestamp = Date.now().toString(16).padStart(16, "0");
+  const hashPart = manifestHash.replace("0x", "").slice(0, 48);
+  return "0x" + hashPart + timestamp;
+}
+function isValidAddress(address) {
+  return address.length >= 46 && address.length <= 48;
+}
+function blocksToTime(blocks) {
+  const seconds = blocks * 3;
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+function parsePlanckString(value) {
+  return BigInt(value);
+}
+
+// src/rpc.ts
+async function getDeveloperProfile(api, account) {
+  const result = await api.rpc.awarizon.getDeveloperProfile(account);
+  const json = result.toJSON();
+  if (!json) return null;
+  return {
+    ...json,
+    staked_riz: BigInt(json.staked_riz ?? "0"),
+    total_deliveries: BigInt(json.total_deliveries ?? "0")
+  };
+}
+async function getDeveloperCampaigns(api, account) {
+  const result = await api.rpc.awarizon.getDeveloperCampaigns(account);
+  return result.toJSON();
+}
+async function getDeveloperManifests(api, account) {
+  const result = await api.rpc.awarizon.getDeveloperManifests(account);
+  return result.toJSON();
+}
+async function getCampaign(api, campaignId) {
+  const result = await api.rpc.awarizon.getCampaign(campaignId);
+  const json = result.toJSON();
+  if (!json) return null;
+  return {
+    ...json,
+    max_deliveries: BigInt(json.max_deliveries ?? "0"),
+    current_deliveries: BigInt(json.current_deliveries ?? "0"),
+    storage_fee_paid: BigInt(json.storage_fee_paid ?? "0")
+  };
+}
+async function getActiveCampaignCount(api) {
+  const result = await api.rpc.awarizon.getActiveCampaignCount();
+  return BigInt(result.toString());
+}
+async function getCampaignDeliveryStatus(api, campaignId) {
+  const result = await api.rpc.awarizon.getCampaignDeliveryStatus(campaignId);
+  const json = result.toJSON();
+  if (!json) return null;
+  return {
+    current_deliveries: BigInt(json.current_deliveries ?? "0"),
+    max_deliveries: BigInt(json.max_deliveries ?? "0"),
+    remaining: BigInt(json.remaining ?? "0"),
+    percentage_used: json.percentage_used
+  };
+}
+async function getInboxCount(api, wallet) {
+  const result = await api.rpc.awarizon.getInboxCount(wallet);
+  return result.toNumber();
+}
+async function getInboxRecord(api, wallet, recordId) {
+  const result = await api.rpc.awarizon.getInboxRecord(wallet, recordId);
+  const json = result.toJSON();
+  if (!json) return null;
+  return json;
+}
+async function getWalletTargetingProfile(api, wallet) {
+  const result = await api.rpc.awarizon.getWalletTargetingProfile(wallet);
+  return result.toJSON();
+}
+async function checkCampaignMatch(api, campaignId, wallet) {
+  const result = await api.rpc.awarizon.checkCampaignMatch(campaignId, wallet);
+  return result.isTrue;
+}
+async function getActiveValidators(api) {
+  const result = await api.rpc.awarizon.getActiveValidators();
+  return result.toJSON();
+}
+async function getValidatorCount(api) {
+  const result = await api.rpc.awarizon.getValidatorCount();
+  return result.toNumber();
+}
+async function getValidatorPerformance(api, account) {
+  const result = await api.rpc.awarizon.getValidatorPerformance(account);
+  return result.toJSON();
+}
+async function getNetworkStats(api) {
+  const result = await api.rpc.awarizon.getNetworkStats();
+  const json = result.toJSON();
+  return {
+    total_wallets: BigInt(String(json.total_wallets ?? "0")),
+    total_deliveries: BigInt(String(json.total_deliveries ?? "0")),
+    active_campaigns: BigInt(String(json.active_campaigns ?? "0")),
+    total_staked: String(json.total_staked ?? "0"),
+    current_epoch: BigInt(String(json.current_epoch ?? "0")),
+    inbox_reserve_balance: String(json.inbox_reserve_balance ?? "0"),
+    total_extrinsics: Number(json.total_extrinsics ?? 0),
+    circulating_supply: String(json.circulating_supply ?? "0"),
+    non_circulating_supply: String(json.non_circulating_supply ?? "0")
+  };
+}
+async function getTokenStats(api) {
+  const result = await api.rpc.awarizon.getTokenStats();
+  return result.toJSON();
+}
+async function getRecentTransactions(api) {
+  const result = await api.rpc.awarizon.getRecentTransactions();
+  return result.toJSON().map((r) => ({
+    block_number: Number(r.block_number ?? 0),
+    extrinsic_index: Number(r.extrinsic_index ?? 0),
+    success: Boolean(r.success)
+  }));
+}
+async function getBlockTransactions(api, blockNumber) {
+  const result = await api.rpc.awarizon.getBlockTransactions(blockNumber);
+  return result.toJSON().map((r) => ({
+    block_number: Number(r.block_number ?? 0),
+    extrinsic_index: Number(r.extrinsic_index ?? 0),
+    success: Boolean(r.success)
+  }));
+}
+async function getVestingSchedule(api, account) {
+  const result = await api.query.vesting.vesting(account);
+  const json = result.toJSON();
+  if (!json || !Array.isArray(json)) return [];
+  return json.map((v) => ({
+    locked: String(v.locked ?? v.Locked ?? "0"),
+    per_block: String(v.perBlock ?? v.per_block ?? "0"),
+    starting_block: Number(v.startingBlock ?? v.starting_block ?? 0)
+  }));
+}
+async function getIdentity(api, account) {
+  const result = await api.rpc.awarizon.getIdentity(account, null);
+  const json = result.toJSON();
+  if (!json) return null;
+  return {
+    account: json.account,
+    rizName: json.riz_name ?? null,
+    rizNameFull: json.riz_name ? json.riz_name + ".riz" : null,
+    displayName: json.display_name ?? null,
+    bio: json.bio ?? null,
+    avatarUri: json.avatar_uri ?? null,
+    website: json.website ?? null,
+    registeredAt: Number(json.registered_at ?? 0),
+    verified: Boolean(json.verified),
+    reputationScore: Number(json.reputation_score ?? 0),
+    linkedAddresses: (json.linked_addresses ?? []).map((la) => ({
+      chain: la.chain,
+      address: la.address,
+      status: la.status,
+      linkedAt: Number(la.linked_at ?? 0)
+    }))
+  };
+}
+async function lookupName(api, name) {
+  const result = await api.rpc.awarizon.lookupName(name, null);
+  const json = result.toJSON();
+  if (!json) return null;
+  const identity = json.identity ? await getIdentity(api, json.account) : null;
+  return {
+    rizName: json.riz_name,
+    account: json.account,
+    identity
+  };
+}
+async function getLinkedAddresses(api, account) {
+  const result = await api.rpc.awarizon.getLinkedAddresses(account, null);
+  const arr = result.toJSON();
+  if (!Array.isArray(arr)) return [];
+  return arr.map((la) => ({
+    chain: la.chain,
+    address: la.address,
+    status: la.status,
+    linkedAt: Number(la.linked_at ?? 0)
+  }));
+}
+async function isNameAvailable(api, name) {
+  const result = await api.rpc.awarizon.isNameAvailable(name, null);
+  return Boolean(result.toJSON());
+}
+async function getTotalIdentities(api) {
+  const result = await api.rpc.awarizon.getTotalIdentities(null);
+  return result.toNumber();
+}
+
+// src/extrinsics/developer.ts
+function buildRegisterDeveloper(api) {
+  return api.tx.awarizonState.registerDeveloper();
+}
+function buildStakeRiz(api, amount) {
+  return api.tx.awarizonState.stakeRiz(amount);
+}
+
+// src/extrinsics/manifests.ts
+function buildRegisterManifest(api, manifestHash, category, metadataUri) {
+  return api.tx.awarizonState.registerManifest(manifestHash, category, metadataUri);
+}
+
+// src/extrinsics/campaigns.ts
+function buildCreateCampaign(api, campaignId, manifestHash, targeting, durationDays, maxDeliveries) {
+  return api.tx.awarizonState.createCampaign(
+    campaignId,
+    manifestHash,
+    targeting,
+    durationDays,
+    maxDeliveries
+  );
+}
+function buildTerminateCampaign(api, campaignId) {
+  return api.tx.awarizonState.terminateCampaign(campaignId);
+}
+function buildExpireCampaign(api, campaignId) {
+  return api.tx.awarizonState.expireCampaign(campaignId);
+}
+function buildAdvanceEpoch(api) {
+  return api.tx.awarizonState.advanceEpoch();
+}
+function buildResetDailyEngagement(api) {
+  return api.tx.awarizonState.resetDailyEngagement();
+}
+
+// src/extrinsics/inbox.ts
+function buildDeliverToInbox(api, wallet, campaignId, recordId) {
+  return api.tx.awarizonState.deliverToInbox(wallet, campaignId, recordId);
+}
+function buildDismissInboxRecord(api, recordId) {
+  return api.tx.awarizonState.dismissInboxRecord(recordId);
+}
+function buildSubmitEngagement(api, recordId, sessionDurationSeconds, interactionCount) {
+  return api.tx.awarizonState.submitEngagement(
+    recordId,
+    sessionDurationSeconds,
+    interactionCount
+  );
+}
+function buildClaimReward(api, recordId) {
+  return api.tx.awarizonState.claimReward(recordId);
+}
+function buildUpdateWalletIndex(api, walletAgeDays, activityCount, categoryHistory, regionCode) {
+  return api.tx.awarizonState.updateWalletIndex(
+    walletAgeDays,
+    activityCount,
+    categoryHistory,
+    regionCode
+  );
+}
+
+// src/extrinsics/targeting.ts
+function buildBloomFilter(api, campaignId) {
+  return api.tx.awarizonTargeting.buildBloomFilter(campaignId);
+}
+function buildCheckWalletMatch(api, campaignId, wallet) {
+  return api.tx.awarizonTargeting.checkWalletMatch(campaignId, wallet);
+}
+function buildRunTargetingBatch(api, campaignId, wallets) {
+  return api.tx.awarizonTargeting.runTargetingBatch(campaignId, wallets);
+}
+
+// src/extrinsics/validators.ts
+function buildRegisterValidator(api, selfStake, regionCode, countryCode) {
+  return api.tx.awarizonConsensus.registerValidator(selfStake, regionCode, countryCode);
+}
+function buildDelegateStake(api, validator, amount) {
+  return api.tx.awarizonConsensus.delegateStake(validator, amount);
+}
+function buildUndelegateStake(api, validator) {
+  return api.tx.awarizonConsensus.undelegateStake(validator);
+}
+function buildUpdatePerformance(api, validator, uptimeBps, finalityBps, blocksBps) {
+  return api.tx.awarizonConsensus.updatePerformance(
+    validator,
+    uptimeBps,
+    finalityBps,
+    blocksBps
+  );
+}
+function buildRunEpochElection(api, epoch) {
+  return api.tx.awarizonConsensus.runEpochElection(epoch);
+}
+function buildSlashValidator(api, validator, reason) {
+  return api.tx.awarizonConsensus.slashValidator(validator, reason);
+}
+
+// src/extrinsics/assets.ts
+function buildCreateAsset(api, id, admin, minBalance) {
+  return api.tx.assets.create(id, admin, minBalance);
+}
+function buildMintAsset(api, id, beneficiary, amount) {
+  return api.tx.assets.mint(id, beneficiary, amount);
+}
+function buildTransferAsset(api, id, target, amount) {
+  return api.tx.assets.transfer(id, target, amount);
+}
+
+// src/wallet.ts
+var import_keyring = require("@polkadot/keyring");
+
+// src/errors.ts
+var AwarizonError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AwarizonError";
+  }
+};
+var DeveloperNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Developer not found", "DeveloperNotFound");
+  }
+};
+var DeveloperAlreadyRegisteredError = class extends AwarizonError {
+  constructor() {
+    super("Developer already registered", "DeveloperAlreadyRegistered");
+  }
+};
+var DeveloperNotVerifiedError = class extends AwarizonError {
+  constructor() {
+    super("Developer not verified", "DeveloperNotVerified");
+  }
+};
+var DeveloperSuspendedError = class extends AwarizonError {
+  constructor() {
+    super("Developer is suspended", "DeveloperSuspended");
+  }
+};
+var ManifestNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Manifest not found", "ManifestNotFound");
+  }
+};
+var ManifestAlreadyRegisteredError = class extends AwarizonError {
+  constructor() {
+    super("Manifest already registered", "ManifestAlreadyRegistered");
+  }
+};
+var ManifestLimitReachedError = class extends AwarizonError {
+  constructor() {
+    super("Manifest limit reached", "ManifestLimitReached");
+  }
+};
+var CampaignNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Campaign not found", "CampaignNotFound");
+  }
+};
+var CampaignNotActiveError = class extends AwarizonError {
+  constructor() {
+    super("Campaign is not active", "CampaignNotActive");
+  }
+};
+var CampaignExpiredError = class extends AwarizonError {
+  constructor() {
+    super("Campaign has expired", "CampaignExpired");
+  }
+};
+var CampaignDeliveryLimitReachedError = class extends AwarizonError {
+  constructor() {
+    super("Campaign delivery limit reached", "CampaignDeliveryLimitReached");
+  }
+};
+var InboxRecordNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Inbox record not found", "InboxRecordNotFound");
+  }
+};
+var InboxAlreadyDeliveredError = class extends AwarizonError {
+  constructor() {
+    super("Already delivered to this inbox", "InboxAlreadyDelivered");
+  }
+};
+var InboxFullError = class extends AwarizonError {
+  constructor() {
+    super("Inbox is full (1000 records)", "InboxFull");
+  }
+};
+var EngagementCooldownActiveError = class extends AwarizonError {
+  constructor() {
+    super("Engagement cooldown is active (24h)", "EngagementCooldownActive");
+  }
+};
+var EngagementDailyLimitReachedError = class extends AwarizonError {
+  constructor() {
+    super("Daily engagement limit reached (10/day)", "EngagementDailyLimitReached");
+  }
+};
+var EngagementInvalidError = class extends AwarizonError {
+  constructor() {
+    super("Engagement does not meet minimum requirements", "EngagementInvalid");
+  }
+};
+var InsufficientStakeError = class extends AwarizonError {
+  constructor() {
+    super("Insufficient stake", "InsufficientStake");
+  }
+};
+var InsufficientBalanceError = class extends AwarizonError {
+  constructor() {
+    super("Insufficient balance", "InsufficientBalance");
+  }
+};
+var TargetingDimensionLimitExceededError = class extends AwarizonError {
+  constructor() {
+    super("Targeting dimension limit exceeded (max 6)", "TargetingDimensionLimitExceeded");
+  }
+};
+var InvalidManifestHashError = class extends AwarizonError {
+  constructor() {
+    super("Invalid manifest hash", "InvalidManifestHash");
+  }
+};
+var InvalidCampaignIdError = class extends AwarizonError {
+  constructor() {
+    super("Invalid campaign ID", "InvalidCampaignId");
+  }
+};
+var UnauthorizedError = class extends AwarizonError {
+  constructor() {
+    super("Unauthorized", "Unauthorized");
+  }
+};
+var EpochNotReadyError = class extends AwarizonError {
+  constructor() {
+    super("Epoch is not ready to advance", "EpochNotReady");
+  }
+};
+var NotExpiredYetError = class extends AwarizonError {
+  constructor() {
+    super("Campaign has not expired yet", "NotExpiredYet");
+  }
+};
+var ResetNotReadyError = class extends AwarizonError {
+  constructor() {
+    super("Daily reset is not ready yet", "ResetNotReady");
+  }
+};
+var ValidatorAlreadyRegisteredError = class extends AwarizonError {
+  constructor() {
+    super("Validator already registered", "ValidatorAlreadyRegistered");
+  }
+};
+var ValidatorNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Validator not found", "ValidatorNotFound");
+  }
+};
+var RegionCapExceededError = class extends AwarizonError {
+  constructor() {
+    super("Region validator cap exceeded (20%)", "RegionCapExceeded");
+  }
+};
+var CountryCapExceededError = class extends AwarizonError {
+  constructor() {
+    super("Country validator cap exceeded (10%)", "CountryCapExceeded");
+  }
+};
+var DelegationNotFoundError = class extends AwarizonError {
+  constructor() {
+    super("Delegation not found", "DelegationNotFound");
+  }
+};
+var CannotDelegateToSelfError = class extends AwarizonError {
+  constructor() {
+    super("Cannot delegate stake to yourself", "CannotDelegateToSelf");
+  }
+};
+var ValidatorNotActiveError = class extends AwarizonError {
+  constructor() {
+    super("Validator is not active", "ValidatorNotActive");
+  }
+};
+var AlreadyDelegatedError = class extends AwarizonError {
+  constructor() {
+    super("Already delegated to this validator", "AlreadyDelegated");
+  }
+};
+var MaxValidatorsReachedError = class extends AwarizonError {
+  constructor() {
+    super("Maximum validator count reached", "MaxValidatorsReached");
+  }
+};
+var ERROR_MAP = {
+  DeveloperNotFound: () => new DeveloperNotFoundError(),
+  DeveloperAlreadyRegistered: () => new DeveloperAlreadyRegisteredError(),
+  DeveloperNotVerified: () => new DeveloperNotVerifiedError(),
+  DeveloperSuspended: () => new DeveloperSuspendedError(),
+  ManifestNotFound: () => new ManifestNotFoundError(),
+  ManifestAlreadyRegistered: () => new ManifestAlreadyRegisteredError(),
+  ManifestLimitReached: () => new ManifestLimitReachedError(),
+  CampaignNotFound: () => new CampaignNotFoundError(),
+  CampaignNotActive: () => new CampaignNotActiveError(),
+  CampaignExpired: () => new CampaignExpiredError(),
+  CampaignDeliveryLimitReached: () => new CampaignDeliveryLimitReachedError(),
+  InboxRecordNotFound: () => new InboxRecordNotFoundError(),
+  InboxAlreadyDelivered: () => new InboxAlreadyDeliveredError(),
+  InboxFull: () => new InboxFullError(),
+  EngagementCooldownActive: () => new EngagementCooldownActiveError(),
+  EngagementDailyLimitReached: () => new EngagementDailyLimitReachedError(),
+  EngagementInvalid: () => new EngagementInvalidError(),
+  InsufficientStake: () => new InsufficientStakeError(),
+  InsufficientBalance: () => new InsufficientBalanceError(),
+  TargetingDimensionLimitExceeded: () => new TargetingDimensionLimitExceededError(),
+  InvalidManifestHash: () => new InvalidManifestHashError(),
+  InvalidCampaignId: () => new InvalidCampaignIdError(),
+  Unauthorized: () => new UnauthorizedError(),
+  EpochNotReady: () => new EpochNotReadyError(),
+  NotExpiredYet: () => new NotExpiredYetError(),
+  ResetNotReady: () => new ResetNotReadyError(),
+  ValidatorAlreadyRegistered: () => new ValidatorAlreadyRegisteredError(),
+  ValidatorNotFound: () => new ValidatorNotFoundError(),
+  RegionCapExceeded: () => new RegionCapExceededError(),
+  CountryCapExceeded: () => new CountryCapExceededError(),
+  DelegationNotFound: () => new DelegationNotFoundError(),
+  CannotDelegateToSelf: () => new CannotDelegateToSelfError(),
+  ValidatorNotActive: () => new ValidatorNotActiveError(),
+  AlreadyDelegated: () => new AlreadyDelegatedError(),
+  MaxValidatorsReached: () => new MaxValidatorsReachedError()
+};
+function parseChainError(error) {
+  const errorStr = String(error);
+  for (const [key, factory] of Object.entries(ERROR_MAP)) {
+    if (errorStr.includes(key)) return factory();
+  }
+  return new AwarizonError(errorStr, "UnknownError", error);
+}
+
+// src/wallet.ts
+function createKeyring() {
+  return new import_keyring.Keyring({ type: "sr25519" });
+}
+function keypairFromMnemonic(mnemonic) {
+  const keyring = createKeyring();
+  return keyring.addFromMnemonic(mnemonic);
+}
+function keypairFromSeed(seed) {
+  const keyring = createKeyring();
+  return keyring.addFromSeed(Buffer.from(seed.replace("0x", ""), "hex"));
+}
+function aliceKeypair() {
+  const keyring = createKeyring();
+  return keyring.addFromUri("//Alice");
+}
+function bobKeypair() {
+  const keyring = createKeyring();
+  return keyring.addFromUri("//Bob");
+}
+async function signAndSend(api, extrinsic, signer) {
+  return new Promise((resolve, reject) => {
+    extrinsic.signAndSend(signer, ({ status, dispatchError }) => {
+      if (status.isInBlock || status.isFinalized) {
+        if (dispatchError) {
+          reject(parseChainError(dispatchError.toString()));
+        } else {
+          resolve({
+            blockHash: status.isInBlock ? status.asInBlock.toHex() : status.asFinalized.toHex(),
+            txHash: extrinsic.hash.toHex()
+          });
+        }
+      }
+    }).catch(reject);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlreadyDelegatedError,
+  AwarizonClient,
+  AwarizonError,
+  BLOCK_TIME_SECONDS,
+  CHAIN_NAME,
+  CampaignDeliveryLimitReachedError,
+  CampaignExpiredError,
+  CampaignNotActiveError,
+  CampaignNotFoundError,
+  CannotDelegateToSelfError,
+  CountryCapExceededError,
+  DEFAULT_CAMPAIGN_DURATION_DAYS,
+  DEFAULT_ENDPOINT,
+  DEVELOPER_MIN_TENURE_DAYS,
+  DelegationNotFoundError,
+  DeveloperAlreadyRegisteredError,
+  DeveloperNotFoundError,
+  DeveloperNotVerifiedError,
+  DeveloperSuspendedError,
+  ENGAGEMENT_COOLDOWN_HOURS,
+  EPOCH_LENGTH_BLOCKS,
+  EngagementCooldownActiveError,
+  EngagementDailyLimitReachedError,
+  EngagementInvalidError,
+  EpochNotReadyError,
+  GENESIS_VALIDATORS,
+  InboxAlreadyDeliveredError,
+  InboxFullError,
+  InboxRecordNotFoundError,
+  InsufficientBalanceError,
+  InsufficientStakeError,
+  InvalidCampaignIdError,
+  InvalidManifestHashError,
+  MAX_CAMPAIGN_DURATION_DAYS,
+  MAX_CATEGORY_HISTORY_ENTRIES,
+  MAX_ENGAGEMENT_EVENTS_PER_DAY,
+  MAX_REGION_CODES_PER_CAMPAIGN,
+  MAX_TARGETING_DIMENSIONS,
+  MICRO_RIZ,
+  MILLI_RIZ,
+  MIN_CAMPAIGN_DURATION_DAYS,
+  MIN_INTERACTIONS,
+  MIN_SESSION_SECONDS,
+  ManifestAlreadyRegisteredError,
+  ManifestLimitReachedError,
+  ManifestNotFoundError,
+  MaxValidatorsReachedError,
+  NotExpiredYetError,
+  PERF_WEIGHT_BLOCKS_BPS,
+  PERF_WEIGHT_FINALITY_BPS,
+  PERF_WEIGHT_SLASH_BPS,
+  PERF_WEIGHT_UPTIME_BPS,
+  PLANCK,
+  RIZ,
+  RegionCapExceededError,
+  ResetNotReadyError,
+  TARGET_VALIDATORS,
+  TargetingDimensionLimitExceededError,
+  UnauthorizedError,
+  ValidatorAlreadyRegisteredError,
+  ValidatorNotActiveError,
+  ValidatorNotFoundError,
+  aliceKeypair,
+  awarizonRpc,
+  awarizonTypes,
+  blocksToTime,
+  bobKeypair,
+  buildAdvanceEpoch,
+  buildBloomFilter,
+  buildCheckWalletMatch,
+  buildClaimReward,
+  buildCreateAsset,
+  buildCreateCampaign,
+  buildDelegateStake,
+  buildDeliverToInbox,
+  buildDismissInboxRecord,
+  buildExpireCampaign,
+  buildMintAsset,
+  buildRegisterDeveloper,
+  buildRegisterManifest,
+  buildRegisterValidator,
+  buildResetDailyEngagement,
+  buildRunEpochElection,
+  buildRunTargetingBatch,
+  buildSlashValidator,
+  buildStakeRiz,
+  buildSubmitEngagement,
+  buildTerminateCampaign,
+  buildTransferAsset,
+  buildUndelegateStake,
+  buildUpdatePerformance,
+  buildUpdateWalletIndex,
+  bytesToHex,
+  checkCampaignMatch,
+  connect,
+  createKeyring,
+  formatRiz,
+  generateCampaignId,
+  getActiveCampaignCount,
+  getActiveValidators,
+  getBlockTransactions,
+  getCampaign,
+  getCampaignDeliveryStatus,
+  getDeveloperCampaigns,
+  getDeveloperManifests,
+  getDeveloperProfile,
+  getIdentity,
+  getInboxCount,
+  getInboxRecord,
+  getLinkedAddresses,
+  getNetworkStats,
+  getRecentTransactions,
+  getTokenStats,
+  getTotalIdentities,
+  getValidatorCount,
+  getValidatorPerformance,
+  getVestingSchedule,
+  getWalletTargetingProfile,
+  hexToBytes,
+  isNameAvailable,
+  isValidAddress,
+  keypairFromMnemonic,
+  keypairFromSeed,
+  lookupName,
+  parseChainError,
+  parsePlanckString,
+  parseRiz,
+  signAndSend
+});
+//# sourceMappingURL=index.js.map