feat: initial Pezkuwi Apps rebrand from polkadot-apps

Rebranded terminology:
- Polkadot → Pezkuwi
- Kusama → Dicle
- Westend → Zagros
- Rococo → PezkuwiChain
- Substrate → Bizinikiwi
- parachain → teyrchain

Custom logos with Kurdistan brand colors (#e6007a → #86e62a):
- bizinikiwi-hexagon.svg
- sora-bizinikiwi.svg
- hezscanner.svg
- heztreasury.svg
- pezkuwiscan.svg
- pezkuwistats.svg
- pezkuwiassembly.svg
- pezkuwiholic.svg

packages/page-bounties/src/hooks/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @pezkuwi/app-bounties authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './useBalance.js';
+export * from './useBounties.js';
+export * from './useBountyStatus.js';
+export * from './useUserRole.js';

packages/page-bounties/src/hooks/useBalance.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2025 @pezkuwi/app-bounties authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DeriveBalancesAll } from '@pezkuwi/api-derive/types';
+import type { Balance } from '@pezkuwi/types/interfaces';
+
+import { createNamedHook, useApi, useCall } from '@pezkuwi/react-hooks';
+
+function useBalanceImpl (accountId: string | null): Balance | undefined {
+  const { api } = useApi();
+  const balancesAll = useCall<DeriveBalancesAll>(api.derive.balances?.all, [accountId]);
+
+  return balancesAll?.transferable || balancesAll?.availableBalance;
+}
+
+export const useBalance = createNamedHook('useBalance', useBalanceImpl);

packages/page-bounties/src/hooks/useBounties.tsx

@@ -0,0 +1,98 @@
+// Copyright 2017-2025 @pezkuwi/app-bounties authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiPromise } from '@pezkuwi/api';
+import type { SubmittableExtrinsicFunction } from '@pezkuwi/api/types';
+import type { DeriveBounties } from '@pezkuwi/api-derive/types';
+import type { Codec } from '@pezkuwi/types/types';
+import type { BN } from '@pezkuwi/util';
+
+import { useMemo } from 'react';
+
+import { createNamedHook, useApi, useBestNumber, useCall } from '@pezkuwi/react-hooks';
+import { BN_ZERO } from '@pezkuwi/util';
+
+interface BountyApiTxs {
+  acceptCurator: SubmittableExtrinsicFunction<'promise'>;
+  approveBounty: SubmittableExtrinsicFunction<'promise'>;
+  awardBounty: SubmittableExtrinsicFunction<'promise'>;
+  claimBounty: SubmittableExtrinsicFunction<'promise'>;
+  closeBounty: SubmittableExtrinsicFunction<'promise'>;
+  extendBountyExpiry: SubmittableExtrinsicFunction<'promise'>;
+  proposeBounty: SubmittableExtrinsicFunction<'promise'>;
+  proposeCurator: SubmittableExtrinsicFunction<'promise'>;
+  unassignCurator: SubmittableExtrinsicFunction<'promise'>;
+}
+
+interface BountyApiConstants {
+  bountyCuratorDeposit: BN;
+  bountyDepositBase: BN;
+  bountyUpdatePeriod?: BN;
+  bountyValueMinimum: BN;
+  dataDepositPerByte: BN;
+  maximumReasonLength: number;
+}
+
+interface BountyApiStatics extends BountyApiConstants, BountyApiTxs {
+  // nothing additional
+}
+
+export interface BountyApi extends BountyApiStatics {
+  bestNumber?: BN;
+  bounties?: DeriveBounties;
+  bountyCount?: BN;
+  childCount?: BN;
+}
+
+function getStatics (api: ApiPromise): BountyApiStatics {
+  const constsBase = api.consts.bounties || api.consts.treasury;
+  const txBase = api.tx.bounties || api.tx.treasury;
+
+  return {
+    // constants
+    bountyCuratorDeposit: (constsBase.bountyCuratorDeposit as (BN & Codec)) || BN_ZERO,
+    bountyDepositBase: constsBase.bountyDepositBase,
+    bountyUpdatePeriod: constsBase.bountyUpdatePeriod,
+    bountyValueMinimum: constsBase.bountyValueMinimum,
+    dataDepositPerByte: constsBase.dataDepositPerByte,
+    maximumReasonLength: constsBase.maximumReasonLength.toNumber(),
+
+    // extrinsics
+    // eslint-disable-next-line sort-keys
+    acceptCurator: txBase.acceptCurator,
+    approveBounty: txBase.approveBounty,
+    awardBounty: txBase.awardBounty,
+    claimBounty: txBase.claimBounty,
+    closeBounty: txBase.closeBounty,
+    extendBountyExpiry: txBase.extendBountyExpiry,
+    proposeBounty: txBase.proposeBounty,
+    proposeCurator: txBase.proposeCurator,
+    unassignCurator: txBase.unassignCurator
+  };
+}
+
+function useBountiesImpl (): BountyApi {
+  const { api } = useApi();
+  const bounties = useCall<DeriveBounties>(api.derive.bounties.bounties);
+  const bountyCount = useCall<BN>((api.query.bounties || api.query.treasury).bountyCount);
+  const childCount = useCall<BN>(api.query.childBounties?.childBountyCount);
+  const bestNumber = useBestNumber();
+
+  const statics = useMemo(
+    () => getStatics(api),
+    [api]
+  );
+
+  return useMemo(
+    (): BountyApi => ({
+      ...statics,
+      bestNumber,
+      bounties,
+      bountyCount,
+      childCount
+    }),
+    [bestNumber, bounties, bountyCount, childCount, statics]
+  );
+}
+
+export const useBounties = createNamedHook('useBounties', useBountiesImpl);

packages/page-bounties/src/hooks/useBountyStatus.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @pezkuwi/app-bounties authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { PalletBountiesBountyStatus } from '@pezkuwi/types/lookup';
+import type { BountyStatusType } from '../types.js';
+
+import { useCallback } from 'react';
+
+import { createNamedHook } from '@pezkuwi/react-hooks';
+
+import { getBountyStatus } from '../helpers/index.js';
+
+function useBountyStatusImpl (status: PalletBountiesBountyStatus): BountyStatusType {
+  const updateStatus = useCallback(() => getBountyStatus(status), [status]);
+
+  return updateStatus();
+}
+
+export const useBountyStatus = createNamedHook('useBountyStatus', useBountyStatusImpl);

packages/page-bounties/src/hooks/useUserRole.ts

@@ -0,0 +1,37 @@
+// Copyright 2017-2025 @pezkuwi/app-bounties authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AccountId } from '@pezkuwi/types/interfaces';
+import type { UserRole } from '../types.js';
+
+import { useMemo } from 'react';
+
+import { createNamedHook, useAccounts, useCollectiveMembers } from '@pezkuwi/react-hooks';
+
+export interface UserRolesInfo { roles: UserRole[], isCurator: boolean }
+
+function useUserRoleImpl (curatorId?: AccountId): UserRolesInfo {
+  const { allAccounts, hasAccounts } = useAccounts();
+  const { isMember } = useCollectiveMembers('council');
+
+  return useMemo((): UserRolesInfo => {
+    const isCurator = !!curatorId && allAccounts.includes(curatorId.toString());
+    const roles: UserRole[] = [];
+
+    if (isCurator) {
+      roles.push('Curator');
+    }
+
+    if (isMember) {
+      roles.push('Member');
+    }
+
+    if (hasAccounts) {
+      roles.push('User');
+    }
+
+    return { isCurator, roles };
+  }, [allAccounts, curatorId, hasAccounts, isMember]);
+}
+
+export const useUserRole = createNamedHook('useUserRole', useUserRoleImpl);