bip-321 0.0.4 → 0.0.5

package/eslint.config.js

@@ -0,0 +1,94 @@
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+import importPlugin from "eslint-plugin-import";
+
+export default [
+  {
+    ignores: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/*.min.js"],
+  },
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        project: "./tsconfig.json",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint,
+      import: importPlugin,
+    },
+    rules: {
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-non-null-assertion": "error",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
+      ],
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-misused-promises": "error",
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/no-unnecessary-condition": "warn",
+      "@typescript-eslint/prefer-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-optional-chain": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/restrict-template-expressions": "error",
+      "@typescript-eslint/no-base-to-string": "error",
+      "@typescript-eslint/require-await": "error",
+      "@typescript-eslint/switch-exhaustiveness-check": "error",
+
+      "no-console": "warn",
+      "no-debugger": "error",
+      eqeqeq: ["error", "always"],
+      "no-var": "error",
+      "prefer-const": "error",
+      "prefer-arrow-callback": "error",
+      "no-throw-literal": "error",
+      "no-return-await": "error",
+      "require-await": "off",
+      "no-async-promise-executor": "error",
+      "no-promise-executor-return": "error",
+
+      "no-eval": "error",
+      "no-implied-eval": "error",
+      "no-new-func": "error",
+      "no-new-wrappers": "error",
+      "no-useless-concat": "error",
+      "prefer-template": "error",
+      "no-lonely-if": "error",
+      "no-else-return": "error",
+      "no-unneeded-ternary": "error",
+      "prefer-destructuring": [
+        "warn",
+        { array: false, object: true },
+        { enforceForRenamedProperties: false },
+      ],
+
+      "import/no-unresolved": "off",
+      "import/named": "error",
+      "import/no-duplicates": "error",
+      "import/no-cycle": "error",
+      "import/no-self-import": "error",
+
+      "no-await-in-loop": "warn",
+    },
+  },
+  {
+    files: ["example.ts", "example.js"],
+    rules: {
+      "no-console": "off",
+    },
+  },
+  {
+    files: ["*.test.ts", "*.test.js", "*.spec.ts", "*.spec.js"],
+    rules: {
+      "@typescript-eslint/no-non-null-assertion": "off",
+    },
+  },
+];

package/example.ts

@@ -47,7 +47,7 @@ const example4 = parseBIP321(
   "bitcoin:?lightning=lnbc15u1p3xnhl2pp5jptserfk3zk4qy42tlucycrfwxhydvlemu9pqr93tuzlv9cc7g3sdqsvfhkcap3xyhx7un8cqzpgxqzjcsp5f8c52y2stc300gl6s4xswtjpc37hrnnr3c9wvtgjfuvqmpm35evq9qyyssqy4lgd8tj637qcjp05rdpxxykjenthxftej7a2zzmwrmrl70fyj9hvj0rewhzj7jfyuwkwcg9g2jpwtk3wkjtwnkdks84hsnu8xps5vsq4gj5hs",
 );
 console.log(`Valid: ${example4.valid}`);
-console.log(`Address in path: ${example4.address || "none"}`);
+console.log(`Address in path: ${example4.address ?? "none"}`);
 console.log(`Payment type: ${example4.paymentMethods[0]?.type}`);
 console.log(`Network: ${example4.paymentMethods[0]?.network}`);
 console.log();
@@ -71,8 +71,8 @@ const example6 = parseBIP321(
 );
 const byNetwork = getPaymentMethodsByNetwork(example6);
 console.log(`Valid: ${example6.valid}`);
-console.log(`Mainnet methods: ${byNetwork.mainnet?.length || 0}`);
-console.log(`Testnet methods: ${byNetwork.testnet?.length || 0}`);
+console.log(`Mainnet methods: ${byNetwork.mainnet?.length ?? 0}`);
+console.log(`Testnet methods: ${byNetwork.testnet?.length ?? 0}`);
 console.log();
 
 // Example 7: Testnet lightning invoice

package/index.test.ts

@@ -30,6 +30,18 @@ const TEST_DATA = {
     signet:
       "lntbs10u1p5s6wgtsp5d8a763exauvdk6s5gwvl8zmuapmgjq05fdv6trasjd4slvgkvzzqpp56vxdyl24hmkpz0tvqq84xdpqqeql3x7kh8tey4uum2cu8jny6djqdq4g9exkgznw3hhyefqyvenyxqzjccqp2rzjqdwy5et9ygczjl2jqmr9e5xm28u3gksjfrf0pht04uwz2lt9d59cypqelcqqq8gqqqqqqqqpqqqqqzsqqc9qxpqysgq0x0pg2s65rnp2cr35td5tq0vwgmnrghkpzt93eypqvvfu5m40pcjl9k2x2m4kqgvz2ez8tzxqgw0nyeg2w60nfky579uakd4mhr3ncgp0xwars",
   },
+  ark: {
+    mainnet:
+      "ark1pwh9vsmezqqpjy9akejayl2vvcse6he97rn40g84xrlvrlnhayuuyefrp9nse2yspqqjl5wpy",
+    testnet:
+      "tark1pm6sr0fpzqqpnzzwxf209kju4qavs4gtumxk30yv2u5ncrvtp72z34axcvrydtdqpqq5838km",
+  },
+  silentPayment: {
+    mainnet:
+      "sp1qqvgwll3hawztz50nx5mcs70ytam4z068c2cw0z37zcg5yj23h65kcqamhqcxal0gerzly0jnkv7x0ar3sjhmh0n5yugyj3kd7ahzfsdw5590ajuk",
+    testnet:
+      "tsp1qq2svvt45f2rzmfr4vwhgvjfjgna92h09g9a9ttpvmz5x5wmscsepyqhkk6tjxzr6v0vj3q87gcrqjq73z6ljylgk4m6vphvkpg4afzwp4ve0nr78",
+  },
 } as const;
 
 describe("BIP-321 Parser", () => {
@@ -42,8 +54,8 @@ describe("BIP-321 Parser", () => {
       expect(result.address).toBe(TEST_DATA.addresses.mainnet.p2pkh);
       expect(result.network).toBe("mainnet");
       expect(result.paymentMethods.length).toBe(1);
-      expect(result.paymentMethods[0]!.type).toBe("onchain");
-      expect(result.paymentMethods[0]!.valid).toBe(true);
+      expect(result.paymentMethods[0]?.type).toBe("onchain");
+      expect(result.paymentMethods[0]?.valid).toBe(true);
     });
 
     test("parses bech32 mainnet address", () => {
@@ -52,7 +64,7 @@ describe("BIP-321 Parser", () => {
       );
       expect(result.valid).toBe(true);
       expect(result.network).toBe("mainnet");
-      expect(result.paymentMethods[0]!.valid).toBe(true);
+      expect(result.paymentMethods[0]?.valid).toBe(true);
     });
 
     test("parses testnet address", () => {
@@ -193,29 +205,113 @@ describe("BIP-321 Parser", () => {
   });
 
   describe("Alternative Payment Methods", () => {
-    test("parses BOLT12 offer", () => {
+    test("parses valid BOLT12 offer", () => {
+      const result = parseBIP321("bitcoin:?lno=lno1qqqq02k20d");
+      expect(result.valid).toBe(true);
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.type).toBe("offer");
+      expect(result.paymentMethods[0]!.valid).toBe(true);
+    });
+
+    test("rejects invalid BOLT12 offer", () => {
       const result = parseBIP321("bitcoin:?lno=lno1bogusoffer");
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.type).toBe("offer");
+      expect(result.paymentMethods[0]!.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes("BOLT12 offer"))).toBe(true);
+    });
+
+    test("parses mainnet silent payment address", () => {
+      const result = parseBIP321(
+        `bitcoin:?sp=${TEST_DATA.silentPayment.mainnet}`,
+      );
       expect(result.valid).toBe(true);
       expect(result.paymentMethods.length).toBe(1);
-      expect(result.paymentMethods[0]!.type).toBe("lno");
+      expect(result.paymentMethods[0]!.type).toBe("silent-payment");
+      expect(result.paymentMethods[0]!.network).toBe("mainnet");
+      expect(result.paymentMethods[0]!.valid).toBe(true);
     });
 
-    test("parses silent payment address", () => {
-      const result = parseBIP321("bitcoin:?sp=sp1qsilentpayment");
+    test("parses testnet silent payment address", () => {
+      const result = parseBIP321(
+        `bitcoin:?sp=${TEST_DATA.silentPayment.testnet}`,
+      );
       expect(result.valid).toBe(true);
       expect(result.paymentMethods.length).toBe(1);
       expect(result.paymentMethods[0]!.type).toBe("silent-payment");
+      expect(result.paymentMethods[0]!.network).toBe("testnet");
+      expect(result.paymentMethods[0]!.valid).toBe(true);
+    });
+
+    test("rejects invalid silent payment address", () => {
+      const result = parseBIP321("bitcoin:?sp=sp1qinvalid");
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.type).toBe("silent-payment");
+      expect(result.paymentMethods[0]!.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes("silent payment"))).toBe(
+        true,
+      );
     });
 
     test("parses multiple payment methods", () => {
       const result = parseBIP321(
-        "bitcoin:?lno=lno1bogusoffer&sp=sp1qsilentpayment",
+        `bitcoin:?lno=lno1qqqq02k20d&sp=${TEST_DATA.silentPayment.mainnet}`,
       );
       expect(result.valid).toBe(true);
       expect(result.paymentMethods.length).toBe(2);
     });
   });
 
+  describe("Ark Addresses", () => {
+    test("parses mainnet Ark address", () => {
+      const result = parseBIP321(`bitcoin:?ark=${TEST_DATA.ark.mainnet}`);
+      expect(result.valid).toBe(true);
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.type).toBe("ark");
+      expect(result.paymentMethods[0]!.network).toBe("mainnet");
+      expect(result.paymentMethods[0]!.valid).toBe(true);
+    });
+
+    test("parses testnet Ark address", () => {
+      const result = parseBIP321(`bitcoin:?ark=${TEST_DATA.ark.testnet}`);
+      expect(result.valid).toBe(true);
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.type).toBe("ark");
+      expect(result.paymentMethods[0]!.network).toBe("testnet");
+      expect(result.paymentMethods[0]!.valid).toBe(true);
+    });
+
+    test("rejects invalid Ark address", () => {
+      const result = parseBIP321("bitcoin:?ark=invalid_ark_address");
+      expect(result.paymentMethods.length).toBe(1);
+      expect(result.paymentMethods[0]!.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes("Ark address"))).toBe(true);
+    });
+
+    test("parses Ark with Bitcoin address", () => {
+      const result = parseBIP321(
+        `bitcoin:${TEST_DATA.addresses.mainnet.p2pkh}?ark=${TEST_DATA.ark.mainnet}`,
+      );
+      expect(result.valid).toBe(true);
+      expect(result.paymentMethods.length).toBe(2);
+      expect(result.paymentMethods[0]!.type).toBe("onchain");
+      expect(result.paymentMethods[1]!.type).toBe("ark");
+      expect(result.paymentMethods[0]!.network).toBe("mainnet");
+      expect(result.paymentMethods[1]!.network).toBe("mainnet");
+    });
+
+    test("validates Ark network matches expected network", () => {
+      const result = parseBIP321(
+        `bitcoin:?ark=${TEST_DATA.ark.mainnet}`,
+        "testnet",
+      );
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes("network mismatch"))).toBe(
+        true,
+      );
+    });
+  });
+
   describe("Network-specific Parameters", () => {
     test("parses bc parameter for mainnet", () => {
       const result = parseBIP321(

package/index.ts

@@ -3,8 +3,17 @@ import { decode as decodeLightning } from "light-bolt11-decoder";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { base58, bech32, bech32m } from "@scure/base";
 
+// Type declaration for missing export in light-bolt12-decoder
+declare module "light-bolt12-decoder" {
+  export function decode(offer: string): {
+    offerRequest: string;
+    sections: Array<{ name: string; value: unknown }>;
+  };
+}
+import { decode as decodeBolt12 } from "light-bolt12-decoder";
+
 export interface PaymentMethod {
-  type: "onchain" | "lightning" | "lno" | "silent-payment" | "other";
+  type: "onchain" | "lightning" | "offer" | "silent-payment" | "ark";
   value: string;
   network?: "mainnet" | "testnet" | "regtest" | "signet";
   valid: boolean;
@@ -115,7 +124,7 @@ function detectAddressNetwork(
       else if (version === 0x6f || version === 0xc4) {
         return "testnet";
       }
-    } catch (e) {
+    } catch {
       return undefined;
     }
   } catch {
@@ -174,12 +183,129 @@ function validateLightningInvoice(invoice: string): {
   }
 }
 
+function validateBolt12Offer(offer: string): {
+  valid: boolean;
+  error?: string;
+} {
+  try {
+    if (!offer || typeof offer !== "string") {
+      return { valid: false, error: "Empty or invalid offer" };
+    }
+
+    const lowerOffer = offer.toLowerCase();
+    if (!lowerOffer.startsWith("ln")) {
+      return { valid: false, error: "Invalid BOLT12 offer format" };
+    }
+
+    decodeBolt12(offer);
+    return { valid: true };
+  } catch (e) {
+    return {
+      valid: false,
+      error: `Invalid BOLT12 offer: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+}
+
+function validateSilentPaymentAddress(address: string): {
+  valid: boolean;
+  network?: "mainnet" | "testnet" | "regtest" | "signet";
+  error?: string;
+} {
+  try {
+    const lowerAddress = address.toLowerCase();
+
+    let network: "mainnet" | "testnet" | undefined;
+    if (lowerAddress.startsWith("sp1q")) {
+      network = "mainnet";
+    } else if (lowerAddress.startsWith("tsp1q")) {
+      network = "testnet";
+    } else {
+      return { valid: false, error: "Invalid silent payment address prefix" };
+    }
+
+    const decoded = bech32m.decode(address as `${string}1${string}`, 1023);
+
+    const expectedPrefix = network === "mainnet" ? "sp" : "tsp";
+    if (decoded.prefix !== expectedPrefix) {
+      return { valid: false, error: "Invalid silent payment address prefix" };
+    }
+
+    // Check version (first word should be 0 for v0, which encodes as 'q')
+    if (decoded.words.length === 0 || decoded.words[0] !== 0) {
+      return { valid: false, error: "Unsupported silent payment version" };
+    }
+
+    // Convert from 5-bit words to bytes
+    const dataWords = decoded.words.slice(1);
+    const data = bech32m.fromWordsUnsafe(dataWords);
+
+    if (!data) {
+      return { valid: false, error: "Invalid silent payment address data" };
+    }
+
+    // BIP-352: v0 addresses must be exactly 66 bytes (33-byte scan key + 33-byte spend key)
+    if (data.length !== 66) {
+      return { valid: false, error: "Invalid silent payment address length" };
+    }
+
+    // Validate both public keys are valid compressed keys (0x02 or 0x03 prefix)
+    const scanKey = data[0];
+    const spendKey = data[33];
+    if (
+      (scanKey !== 0x02 && scanKey !== 0x03) ||
+      (spendKey !== 0x02 && spendKey !== 0x03)
+    ) {
+      return {
+        valid: false,
+        error: "Invalid public key format in silent payment address",
+      };
+    }
+
+    return { valid: true, network };
+  } catch (e) {
+    return {
+      valid: false,
+      error: `Invalid silent payment address: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+}
+
+function validateArkAddress(address: string): {
+  valid: boolean;
+  network?: "mainnet" | "testnet" | "regtest" | "signet";
+  error?: string;
+} {
+  try {
+    const lowerAddress = address.toLowerCase();
+
+    if (lowerAddress.startsWith("ark1")) {
+      const decoded = bech32m.decode(address as `${string}1${string}`, 1023);
+      if (decoded.prefix === "ark") {
+        return { valid: true, network: "mainnet" };
+      }
+    } else if (lowerAddress.startsWith("tark1")) {
+      const decoded = bech32m.decode(address as `${string}1${string}`, 1023);
+      if (decoded.prefix === "tark") {
+        return { valid: true, network: "testnet" };
+      }
+    }
+
+    return { valid: false, error: "Invalid Ark address format" };
+  } catch (e) {
+    return {
+      valid: false,
+      error: `Invalid Ark address: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+}
+
 function validatePopUri(popUri: string): { valid: boolean; error?: string } {
   try {
     const decoded = decodeURIComponent(popUri);
     const schemeMatch = decoded.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):?/);
 
-    if (schemeMatch && schemeMatch[1]) {
+    if (schemeMatch?.[1]) {
       const scheme = schemeMatch[1].toLowerCase();
       if (FORBIDDEN_POP_SCHEMES.includes(scheme)) {
         return { valid: false, error: `Forbidden pop scheme: ${scheme}` };
@@ -268,7 +394,7 @@ export function parseBIP321(
       }
 
       const lowerKey = key.toLowerCase();
-      const count = (seenKeys.get(lowerKey) || 0) + 1;
+      const count = (seenKeys.get(lowerKey) ?? 0) + 1;
       seenKeys.set(lowerKey, count);
 
       if (lowerKey === "label") {
@@ -308,7 +434,7 @@ export function parseBIP321(
           // Keep pop value encoded as per spec
           const validation = validatePopUri(value);
           if (!validation.valid) {
-            result.errors.push(validation.error || "Invalid pop URI");
+            result.errors.push(validation.error ?? "Invalid pop URI");
             if (lowerKey === "req-pop") {
               result.valid = false;
             }
@@ -327,28 +453,47 @@ export function parseBIP321(
           error: validation.error,
         });
         if (!validation.valid) {
-          result.errors.push(validation.error || "Invalid lightning invoice");
+          result.errors.push(validation.error ?? "Invalid lightning invoice");
         }
       } else if (lowerKey === "lno") {
         const decodedValue = decodeURIComponent(value);
+        const validation = validateBolt12Offer(decodedValue);
         result.paymentMethods.push({
-          type: "lno",
+          type: "offer",
           value: decodedValue,
-          valid: true,
+          valid: validation.valid,
+          error: validation.error,
         });
+        if (!validation.valid) {
+          result.errors.push(validation.error ?? "Invalid BOLT12 offer");
+        }
       } else if (lowerKey === "sp") {
         const decodedValue = decodeURIComponent(value);
-        const isSilentPayment = decodedValue.toLowerCase().startsWith("sp1");
+        const validation = validateSilentPaymentAddress(decodedValue);
         result.paymentMethods.push({
           type: "silent-payment",
           value: decodedValue,
-          valid: isSilentPayment,
-          error: isSilentPayment
-            ? undefined
-            : "Invalid silent payment address format",
+          network: validation.network,
+          valid: validation.valid,
+          error: validation.error,
         });
-        if (!isSilentPayment) {
-          result.errors.push("Invalid silent payment address format");
+        if (!validation.valid) {
+          result.errors.push(
+            validation.error ?? "Invalid silent payment address",
+          );
+        }
+      } else if (lowerKey === "ark") {
+        const decodedValue = decodeURIComponent(value);
+        const validation = validateArkAddress(decodedValue);
+        result.paymentMethods.push({
+          type: "ark",
+          value: decodedValue,
+          network: validation.network,
+          valid: validation.valid,
+          error: validation.error,
+        });
+        if (!validation.valid) {
+          result.errors.push(validation.error ?? "Invalid Ark address");
         }
       } else if (
         lowerKey === "bc" ||
@@ -382,7 +527,7 @@ export function parseBIP321(
         if (!validation.valid || !networkMatches) {
           result.errors.push(
             !validation.valid
-              ? validation.error!
+              ? (validation.error ?? "Invalid address")
               : `Address network mismatch for ${lowerKey} parameter`,
           );
           result.valid = false;
@@ -392,9 +537,7 @@ export function parseBIP321(
         result.errors.push(`Unknown required parameter: ${key}`);
         result.valid = false;
       } else {
-        if (!result.optionalParams[lowerKey]) {
-          result.optionalParams[lowerKey] = [];
-        }
+        result.optionalParams[lowerKey] ??= [];
         result.optionalParams[lowerKey].push(decodeURIComponent(value));
       }
     }
@@ -442,10 +585,17 @@ export function getPaymentMethodsByNetwork(
   };
 
   for (const method of result.paymentMethods) {
-    if (method.network && byNetwork[method.network]) {
-      byNetwork[method.network]!.push(method);
+    const { network } = method;
+    if (network && network in byNetwork) {
+      const networkArray = byNetwork[network];
+      if (networkArray) {
+        networkArray.push(method);
+      }
     } else {
-      byNetwork.unknown!.push(method);
+      const unknownArray = byNetwork.unknown;
+      if (unknownArray) {
+        unknownArray.push(method);
+      }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bip-321",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A TypeScript/JavaScript library for parsing BIP-321 Bitcoin URI scheme with support for multiple payment methods",
   "type": "module",
   "main": "./index.ts",
@@ -16,7 +16,7 @@
     "test": "bun test",
     "example": "bun example.ts",
     "check": "tsc --noEmit",
-    "lint": "oxlint"
+    "lint": "eslint ."
   },
   "keywords": [
     "bitcoin",
@@ -45,11 +45,15 @@
     "@noble/hashes": "^2.0.1",
     "@scure/base": "^2.0.0",
     "bitcoinjs-lib": "^7.0.0",
-    "light-bolt11-decoder": "^3.2.0"
+    "light-bolt11-decoder": "^3.2.0",
+    "light-bolt12-decoder": "^1.0.3"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "oxlint": "^1.26.0"
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "eslint": "^9.39.1",
+    "eslint-plugin-import": "^2.32.0"
   },
   "peerDependencies": {
     "typescript": "^5"

package/oxlintrc.json

@@ -1,23 +0,0 @@
-{
-  "categories": {
-    "correctness": "warn",
-    "suspicious": "warn",
-    "pedantic": "warn",
-    "perf": "warn",
-    "style": "warn",
-    "restriction": "warn"
-  },
-  "rules": {
-    "typescript/no-explicit-any": "error",
-    "typescript/no-non-null-assertion": "error",
-    "no-console": "warn",
-    "no-debugger": "error",
-    "eqeqeq": "error"
-  },
-  "ignorePatterns": [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/*.min.js"
-  ]
-}