@kingdomchain/wallet-client 0.4.3 → 0.5.0

package/dist/index.js

@@ -2,7 +2,7 @@ import { toHex, fromHex, toBase64, fromBase64 } from '@cosmjs/encoding';
 import { sha256 } from '@noble/hashes/sha256';
 import * as ed from '@noble/ed25519';
 import { Registry, DirectSecp256k1Wallet, DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
-import { defaultRegistryTypes, SigningStargateClient } from '@cosmjs/stargate';
+import { defaultRegistryTypes, SigningStargateClient, coins } from '@cosmjs/stargate';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import SignClient from '@walletconnect/sign-client';
 import { Bip39, EnglishMnemonic, Slip10, Slip10Curve, stringToPath } from '@cosmjs/crypto';
@@ -711,6 +711,61 @@ function fromTimestamp(t) {
   millis += (t.nanos || 0) / 1e6;
   return new globalThis.Date(millis);
 }
+function createBaseMsgClaimReward() {
+  return { claimer: "", day_id: 0n };
+}
+var MsgClaimReward = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.claimer !== "") {
+      writer.uint32(10).string(message.claimer);
+    }
+    if (message.day_id !== 0n) {
+      if (BigInt.asUintN(64, message.day_id) !== message.day_id) {
+        throw new globalThis.Error("value provided for field message.day_id of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.day_id);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgClaimReward();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.claimer = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.day_id = reader.uint64();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  create(base) {
+    return MsgClaimReward.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgClaimReward();
+    message.claimer = object.claimer ?? "";
+    message.day_id = object.day_id !== void 0 && object.day_id !== null ? BigInt(object.day_id) : 0n;
+    return message;
+  }
+};
 function createBaseMsgRegisterProvider() {
   return {
     authority: "",
@@ -1502,8 +1557,16 @@ var CITIZEN_MSG_TYPES = [
   ["/isatheword.kingdomchain.citizen.v1.MsgFinalizeRecovery", wrapMsgFns(MsgFinalizeRecovery)],
   ["/isatheword.kingdomchain.citizen.v1.MsgCancelRecovery", wrapMsgFns(MsgCancelRecovery)]
 ];
+var CITIZEN_REWARDS_MSG_TYPES = [
+  ["/isatheword.kingdomchain.citizenrewards.v1.MsgClaimReward", wrapMsgFns(MsgClaimReward)]
+];
 function createKingdomChainRegistry() {
-  return new Registry([...defaultRegistryTypes, ...COMPLIANCE_MSG_TYPES, ...CITIZEN_MSG_TYPES]);
+  return new Registry([
+    ...defaultRegistryTypes,
+    ...COMPLIANCE_MSG_TYPES,
+    ...CITIZEN_MSG_TYPES,
+    ...CITIZEN_REWARDS_MSG_TYPES
+  ]);
 }
 
 // src/chainConstants.ts
@@ -3115,6 +3178,213 @@ async function signCitizenshipAttestation(params) {
   return { signature, input };
 }
 
-export { ATTESTATION_TYPE_CITIZENSHIP_APPLICATION, ATTESTATION_TYPE_RECOVERY, ApplicationStatus, BECH32_PREFIX, CHAIN_COIN_TYPE, DEFAULT_CHAIN_ID, DEFAULT_REST_URL, DEFAULT_RPC_URL, EMBEDDED_WALLET_KDF_PBKDF2, EMBEDDED_WALLET_KDF_PIN, EMBEDDED_WALLET_KDF_PRF, EMBEDDED_WALLET_KEY_DIRECT_ENTROPY, EMBEDDED_WALLET_KEY_HD_DERIVED, EMBEDDED_WALLET_PASSCODE_MAX_LENGTH, EMBEDDED_WALLET_PASSCODE_MIN_LENGTH, EMBEDDED_WALLET_PASSKEY_PBKDF2_ITERATIONS, EMBEDDED_WALLET_PIN_PBKDF2_ITERATIONS, EMBEDDED_WALLET_RECOVERY_PHRASE_DIRECT_ENTROPY_WARNING, EMBEDDED_WALLET_RECOVERY_PHRASE_GENERAL_WARNING, EMBEDDED_WALLET_VAULT_VERSION, EmbeddedWalletBackupRequiredError, EmbeddedWalletDecryptError, EmbeddedWalletLockoutError, EmbeddedWalletVaultError, EmbeddedWalletWeakPasscodeError, InvalidChainConfigError, MsgSubmitApplication, MsgSubmitRecoveryAttestation, PASSCODE_LOCKOUT_FAILURE_THRESHOLD, PASSCODE_LOCKOUT_INITIAL_MS, PASSCODE_LOCKOUT_MAX_MS, RecoveryAttestationStatus, RpcConnectionError, UKDR_DECIMALS, UKDR_DISPLAY_DENOM, UKDR_MINIMAL_DENOM, VAULT_LEGACY_KEY, WALLETCONNECT_COSMOS_METHODS, WALLETCONNECT_COSMOS_NAMESPACE, WEBAUTHN_RP_NAME, WalletAccountError, WalletConnectNotInitializedError, WalletConnectSessionError, WalletConnectSigningError, WalletConnectionError, WalletConnectionRejectedError, WalletNotInstalledError, WebAuthnUnavailableError, WebAuthnUserCancelledError, acknowledgeEmbeddedBackup, addressFromHdMnemonic, addressFromPrivateKey, assertPasscodeAllowedForCreation, assertPasscodeUnlockAllowed, assertPasskey, assertValidPasscode, assertValidRecoveryMnemonic, assertVaultPermitsTransaction, attestationSignPayload, buildKingdomChainInfo, buildRequiredCosmosNamespaces, buildSubmitApplicationMsg, clearEmbeddedWallet, clearPasscodeLockoutRecord, clearVaultFromIndexedDb, computePasscodeLockoutDurationMs, connectCosmostation, connectKeplr, connectLeap, connectWalletConnect, createBrowserSigningClient, createEmbeddedWallet, createHdDerivedPlaintext, createKingdomChainRegistry, createPasskeyMaterialFromAssertion, createPbkdf2Salt, createWalletConnectOfflineSigner, decodeCredentialId, decodeDirectEntropyMnemonic, decryptWalletPayload, defaultEmbeddedHdPath, deriveKekFromPasscode, deriveKekFromPbkdf2, deriveKekFromPrf, derivePrivateKeyFromHdMnemonic, detectRecoveryMnemonicKeyType, detectWebAuthnPrfCapabilities, disconnectWalletConnect, downloadEmbeddedBackupFile, embeddedPlaintextToSigner, enableEmbeddedPasskeyUnlock, encodeCredentialId, encodeDirectEntropyMnemonic, encryptWalletPayload, evaluatePasscodeStrength, exportEncryptedBackup, getCosmostationKeplrApi, getEmbeddedOfflineSigner, getEmbeddedWalletSession, getPasscodeLockoutState, hasEmbeddedWallet, hasLegacyEmbeddedWallet, hasMixedCharacterClasses, importEmbeddedBackup, initWalletConnectClient, isCosmostationAvailable, isKeplrAvailable, isLeapAvailable, loadPasscodeLockoutRecord, loadVaultFromIndexedDb, lockEmbeddedWallet, markVaultBackupAcknowledged, migrateLegacyEmbeddedWallet, normalizePasscode, normalizeRecoveryMnemonic, parseEncryptedBackup, parseWalletConnectAccount, plaintextFromRecoveryMnemonic, providerSeedFromHex, publicKeyFromPrivateSeed, readPrfOutput, recordPasscodeUnlockFailure, recordPasscodeUnlockSuccess, recoverEmbeddedWalletFromMnemonic, recoveryMnemonicAddress, recoveryMnemonicFromPlaintext, registerPasskey, resolvePlaintextKeyType, resolveVaultStorageKey, restoreWalletConnectSession, revealEmbeddedRecoveryPhrase, savePasscodeLockoutRecord, saveVaultToIndexedDb, selectEmbeddedWalletKdf, serializeBackupFile, signAttestationPayload, signCitizenshipAttestation, suggestAndConnect, toWalletConnectCosmosChainId, unlockEmbeddedWallet, validateChainConfig, vaultUsesPasscodeUnlock, vaultUsesPasskeyUnlock };
+// src/amount.ts
+function parseKdrToUkdr(amountKdr) {
+  const trimmed = amountKdr.trim();
+  if (!trimmed) {
+    throw new Error("Amount is required");
+  }
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error("Amount must be a positive number");
+  }
+  const [whole, frac = ""] = trimmed.split(".");
+  if (frac.length > UKDR_DECIMALS) {
+    throw new Error(`Amount supports at most ${UKDR_DECIMALS} decimal places`);
+  }
+  const paddedFrac = frac.padEnd(UKDR_DECIMALS, "0");
+  const ukdr = BigInt(whole + paddedFrac);
+  if (ukdr <= 0n) {
+    throw new Error("Amount must be greater than zero");
+  }
+  return ukdr.toString();
+}
+function formatUkdrAsKdr(amountUkdr) {
+  const raw = typeof amountUkdr === "bigint" ? amountUkdr : BigInt(amountUkdr || "0");
+  const negative = raw < 0n;
+  const abs = negative ? -raw : raw;
+  const whole = abs / 1000000n;
+  const frac = abs % 1000000n;
+  let fracStr = frac.toString().padStart(UKDR_DECIMALS, "0").replace(/0+$/, "");
+  const formatted = fracStr ? `${whole}.${fracStr}` : whole.toString();
+  return negative ? `-${formatted}` : formatted;
+}
+function ukdrCoin(amountUkdr) {
+  return {
+    denom: UKDR_MINIMAL_DENOM,
+    amount: typeof amountUkdr === "bigint" ? amountUkdr.toString() : amountUkdr
+  };
+}
+
+// src/restQuery.ts
+var RestQueryError = class extends Error {
+  constructor(message, status, cause) {
+    super(message, { cause });
+    this.status = status;
+    this.name = "RestQueryError";
+  }
+  status;
+};
+async function restGet(restUrl, path) {
+  const base = restUrl.replace(/\/$/, "");
+  const res = await fetch(`${base}${path}`);
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new RestQueryError(
+      body ? `LCD request failed (${res.status}): ${body}` : `LCD request failed (${res.status})`,
+      res.status
+    );
+  }
+  return await res.json();
+}
+async function fetchUkdrBalance(restUrl, address) {
+  const data = await restGet(
+    restUrl,
+    `/cosmos/bank/v1beta1/balances/${encodeURIComponent(address)}`
+  );
+  const coin = data.balances.find((b) => b.denom === UKDR_MINIMAL_DENOM);
+  return coin?.amount ?? "0";
+}
+async function fetchUnclaimedFinalizedRewards(restUrl, address) {
+  const data = await restGet(
+    restUrl,
+    `/isatheword/kingdomchain/citizenrewards/v1/unclaimed_finalized_rewards/${encodeURIComponent(address)}`
+  );
+  return data.rewards ?? [];
+}
+async function fetchFeeGrantGranter(restUrl, grantee) {
+  try {
+    const data = await restGet(
+      restUrl,
+      `/cosmos/feegrant/v1beta1/allowances/${encodeURIComponent(grantee)}`
+    );
+    const first = data.allowances?.[0];
+    return first?.granter?.trim() || null;
+  } catch (err) {
+    if (err instanceof RestQueryError && err.status === 404) {
+      return null;
+    }
+    throw err;
+  }
+}
+var CitizenTxError = class extends Error {
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.code = code;
+    this.name = "CitizenTxError";
+  }
+  code;
+};
+var DEFAULT_GAS = "200000";
+var DEFAULT_FEE_UKDR = "5000";
+function buildSendUkdrMsg(fromAddress, toAddress, amountKdr) {
+  if (!fromAddress.trim() || !toAddress.trim()) {
+    throw new CitizenTxError("Sender and recipient are required", "INVALID_INPUT");
+  }
+  const amountUkdr = parseKdrToUkdr(amountKdr);
+  return {
+    typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+    value: {
+      fromAddress,
+      toAddress,
+      amount: [ukdrCoin(amountUkdr)]
+    }
+  };
+}
+function buildClaimRewardMsg(claimer, dayId) {
+  if (!claimer.trim()) {
+    throw new CitizenTxError("Claimer address is required", "INVALID_INPUT");
+  }
+  const day = typeof dayId === "bigint" ? dayId : BigInt(dayId);
+  if (day <= 0n) {
+    throw new CitizenTxError("Reward day is required", "INVALID_INPUT");
+  }
+  return {
+    typeUrl: "/isatheword.kingdomchain.citizenrewards.v1.MsgClaimReward",
+    value: MsgClaimReward.fromPartial({
+      claimer,
+      day_id: day
+    })
+  };
+}
+function defaultUkdrTxFee(feeUkdr = DEFAULT_FEE_UKDR, feeGranter) {
+  return {
+    amount: coins(feeUkdr, UKDR_MINIMAL_DENOM),
+    gas: DEFAULT_GAS,
+    ...feeGranter ? { granter: feeGranter } : {}
+  };
+}
+function classifyBroadcastFailure(rawLog, code) {
+  const log = rawLog.toLowerCase();
+  if (log.includes("insufficient funds") || log.includes("insufficient fee")) {
+    return log.includes("fee") ? "INSUFFICIENT_FEE" : "INSUFFICIENT_BALANCE";
+  }
+  if (log.includes("account sequence mismatch") || log.includes("wrong sequence")) {
+    return "SEQUENCE_MISMATCH";
+  }
+  if (code !== 0) {
+    return "TX_FAILED";
+  }
+  return "TX_FAILED";
+}
+function citizenTxErrorMessage(code) {
+  switch (code) {
+    case "INSUFFICIENT_FEE":
+      return "This transaction needs a little more KDR for network fees. If you have not claimed yet, ask support to enable sponsored claim fees.";
+    case "INSUFFICIENT_BALANCE":
+      return "You do not have enough KDR for this transfer.";
+    case "SEQUENCE_MISMATCH":
+      return "Your wallet is out of sync. Refresh the page and try again.";
+    case "TIMEOUT":
+      return "The network is taking longer than usual. Your transaction may still confirm \u2014 check again in a moment.";
+    case "INVALID_INPUT":
+      return "Please check the amount and address and try again.";
+    case "TX_FAILED":
+    default:
+      return "The transaction could not be completed. Please try again.";
+  }
+}
+async function broadcastAndConfirmTx(client, signerAddress, messages, fee, memo = "", options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? 1500;
+  const timeoutMs = options.timeoutMs ?? 9e4;
+  let deliverTx;
+  try {
+    deliverTx = await client.signAndBroadcast(signerAddress, messages, fee, memo);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.toLowerCase().includes("insufficient")) {
+      throw new CitizenTxError(citizenTxErrorMessage("INSUFFICIENT_FEE"), "INSUFFICIENT_FEE", err);
+    }
+    throw new CitizenTxError(citizenTxErrorMessage("TX_FAILED"), "TX_FAILED", err);
+  }
+  if (deliverTx.code !== 0) {
+    const code = classifyBroadcastFailure(deliverTx.rawLog ?? "", deliverTx.code);
+    throw new CitizenTxError(citizenTxErrorMessage(code), code);
+  }
+  const hash = deliverTx.transactionHash;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const indexed = await client.getTx(hash);
+    if (indexed) {
+      if (indexed.code !== 0) {
+        const code = classifyBroadcastFailure(indexed.rawLog ?? "", indexed.code);
+        throw new CitizenTxError(citizenTxErrorMessage(code), code);
+      }
+      return {
+        hash,
+        height: indexed.height,
+        code: indexed.code,
+        rawLog: indexed.rawLog ?? "",
+        deliverTx: indexed
+      };
+    }
+    await sleep(pollIntervalMs);
+  }
+  throw new CitizenTxError(citizenTxErrorMessage("TIMEOUT"), "TIMEOUT");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { ATTESTATION_TYPE_CITIZENSHIP_APPLICATION, ATTESTATION_TYPE_RECOVERY, ApplicationStatus, BECH32_PREFIX, CHAIN_COIN_TYPE, CitizenTxError, DEFAULT_CHAIN_ID, DEFAULT_REST_URL, DEFAULT_RPC_URL, EMBEDDED_WALLET_KDF_PBKDF2, EMBEDDED_WALLET_KDF_PIN, EMBEDDED_WALLET_KDF_PRF, EMBEDDED_WALLET_KEY_DIRECT_ENTROPY, EMBEDDED_WALLET_KEY_HD_DERIVED, EMBEDDED_WALLET_PASSCODE_MAX_LENGTH, EMBEDDED_WALLET_PASSCODE_MIN_LENGTH, EMBEDDED_WALLET_PASSKEY_PBKDF2_ITERATIONS, EMBEDDED_WALLET_PIN_PBKDF2_ITERATIONS, EMBEDDED_WALLET_RECOVERY_PHRASE_DIRECT_ENTROPY_WARNING, EMBEDDED_WALLET_RECOVERY_PHRASE_GENERAL_WARNING, EMBEDDED_WALLET_VAULT_VERSION, EmbeddedWalletBackupRequiredError, EmbeddedWalletDecryptError, EmbeddedWalletLockoutError, EmbeddedWalletVaultError, EmbeddedWalletWeakPasscodeError, InvalidChainConfigError, MsgClaimReward, MsgSubmitApplication, MsgSubmitRecoveryAttestation, PASSCODE_LOCKOUT_FAILURE_THRESHOLD, PASSCODE_LOCKOUT_INITIAL_MS, PASSCODE_LOCKOUT_MAX_MS, RecoveryAttestationStatus, RestQueryError, RpcConnectionError, UKDR_DECIMALS, UKDR_DISPLAY_DENOM, UKDR_MINIMAL_DENOM, VAULT_LEGACY_KEY, WALLETCONNECT_COSMOS_METHODS, WALLETCONNECT_COSMOS_NAMESPACE, WEBAUTHN_RP_NAME, WalletAccountError, WalletConnectNotInitializedError, WalletConnectSessionError, WalletConnectSigningError, WalletConnectionError, WalletConnectionRejectedError, WalletNotInstalledError, WebAuthnUnavailableError, WebAuthnUserCancelledError, acknowledgeEmbeddedBackup, addressFromHdMnemonic, addressFromPrivateKey, assertPasscodeAllowedForCreation, assertPasscodeUnlockAllowed, assertPasskey, assertValidPasscode, assertValidRecoveryMnemonic, assertVaultPermitsTransaction, attestationSignPayload, broadcastAndConfirmTx, buildClaimRewardMsg, buildKingdomChainInfo, buildRequiredCosmosNamespaces, buildSendUkdrMsg, buildSubmitApplicationMsg, citizenTxErrorMessage, clearEmbeddedWallet, clearPasscodeLockoutRecord, clearVaultFromIndexedDb, computePasscodeLockoutDurationMs, connectCosmostation, connectKeplr, connectLeap, connectWalletConnect, createBrowserSigningClient, createEmbeddedWallet, createHdDerivedPlaintext, createKingdomChainRegistry, createPasskeyMaterialFromAssertion, createPbkdf2Salt, createWalletConnectOfflineSigner, decodeCredentialId, decodeDirectEntropyMnemonic, decryptWalletPayload, defaultEmbeddedHdPath, defaultUkdrTxFee, deriveKekFromPasscode, deriveKekFromPbkdf2, deriveKekFromPrf, derivePrivateKeyFromHdMnemonic, detectRecoveryMnemonicKeyType, detectWebAuthnPrfCapabilities, disconnectWalletConnect, downloadEmbeddedBackupFile, embeddedPlaintextToSigner, enableEmbeddedPasskeyUnlock, encodeCredentialId, encodeDirectEntropyMnemonic, encryptWalletPayload, evaluatePasscodeStrength, exportEncryptedBackup, fetchFeeGrantGranter, fetchUkdrBalance, fetchUnclaimedFinalizedRewards, formatUkdrAsKdr, getCosmostationKeplrApi, getEmbeddedOfflineSigner, getEmbeddedWalletSession, getPasscodeLockoutState, hasEmbeddedWallet, hasLegacyEmbeddedWallet, hasMixedCharacterClasses, importEmbeddedBackup, initWalletConnectClient, isCosmostationAvailable, isKeplrAvailable, isLeapAvailable, loadPasscodeLockoutRecord, loadVaultFromIndexedDb, lockEmbeddedWallet, markVaultBackupAcknowledged, migrateLegacyEmbeddedWallet, normalizePasscode, normalizeRecoveryMnemonic, parseEncryptedBackup, parseKdrToUkdr, parseWalletConnectAccount, plaintextFromRecoveryMnemonic, providerSeedFromHex, publicKeyFromPrivateSeed, readPrfOutput, recordPasscodeUnlockFailure, recordPasscodeUnlockSuccess, recoverEmbeddedWalletFromMnemonic, recoveryMnemonicAddress, recoveryMnemonicFromPlaintext, registerPasskey, resolvePlaintextKeyType, resolveVaultStorageKey, restoreWalletConnectSession, revealEmbeddedRecoveryPhrase, savePasscodeLockoutRecord, saveVaultToIndexedDb, selectEmbeddedWalletKdf, serializeBackupFile, signAttestationPayload, signCitizenshipAttestation, suggestAndConnect, toWalletConnectCosmosChainId, ukdrCoin, unlockEmbeddedWallet, validateChainConfig, vaultUsesPasscodeUnlock, vaultUsesPasskeyUnlock };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map