@meshsdk/core-cst 1.6.0-alpha.11

package/README.md

@@ -0,0 +1,5 @@
+# mesh-core-cst
+
+Types and utilities functions between Mesh and [cardano-js-sdk](https://github.com/input-output-hk/cardano-js-sdk)
+
+[meshjs.dev](https://meshjs.dev/)

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@meshsdk/core-cst",
+  "version": "1.6.0-alpha.11",
+  "description": "",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build:mesh": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint",
+    "test": "jest --verbose",
+    "clean": "rm -rf .turbo && rm -rf dist && rm -rf node_modules",
+    "format": "prettier --check . --ignore-path ../../.gitignore"
+  },
+  "devDependencies": {
+    "@meshsdk/eslint-config": "*",
+    "@meshsdk/typescript-config": "*",
+    "@types/pbkdf2": "^3.1.2",
+    "eslint": "^8.57.0",
+    "ts-jest": "^29.1.4",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@cardano-sdk/core": "^0.35.4",
+    "@cardano-sdk/crypto": "^0.1.28",
+    "@cardano-sdk/util": "^0.15.4",
+    "@meshsdk/common": "*",
+    "@stricahq/bip32ed25519": "^1.0.4",
+    "hash.js": "^1.1.7",
+    "pbkdf2": "^3.1.2"
+  },
+  "prettier": "@meshsdk/prettier-config"
+}

package/src/cip8/index.ts

@@ -0,0 +1,24 @@
+import { DataSignature } from "@meshsdk/common";
+
+import { PrivateKey, PublicKey } from "../stricahq";
+
+export const signData = (
+  data: string,
+  privateKey: PrivateKey,
+): DataSignature => {
+  const payload = Buffer.from(data);
+  const signature = privateKey.sign(payload);
+
+  return {
+    key: privateKey.toPublicKey().toBytes().toString("hex"),
+    signature: signature.toString("hex"),
+  };
+};
+
+export const checkSignature = (
+  data: string,
+  { key, signature }: DataSignature,
+) => {
+  const publicKey = new PublicKey(Buffer.from(key, "hex"));
+  return publicKey.verify(Buffer.from(signature, "hex"), Buffer.from(data));
+};

package/src/index.ts

@@ -0,0 +1,16 @@
+import { Cardano, Serialization } from "@cardano-sdk/core";
+
+import { PrivateKey, PublicKey } from "./stricahq";
+
+export * from "./types";
+export * from "./cip8";
+export * from "./resolvers";
+export * from "./serializer";
+export * from "./utils";
+
+export { Cardano, Serialization };
+export { PrivateKey, PublicKey };
+
+export * as CardanoSDKUtil from "@cardano-sdk/util";
+export * as Crypto from "@cardano-sdk/crypto";
+export * as CardanoSDK from "@cardano-sdk/core";

package/src/resolvers/index.ts

@@ -0,0 +1,141 @@
+import { Cardano } from "@cardano-sdk/core";
+import { blake2b } from "@cardano-sdk/crypto";
+import { HexBlob } from "@cardano-sdk/util";
+
+import { Data, NativeScript, PlutusScript } from "@meshsdk/common";
+
+import { Ed25519KeyHashHex, EnterpriseAddress } from "../types";
+import {
+  deserializePlutusScript,
+  deserializeTx,
+  toAddress,
+  toBaseAddress,
+  toEnterpriseAddress,
+  toNativeScript,
+  toPlutusData,
+  toRewardAddress,
+  toScriptRef,
+} from "../utils";
+import { buildRewardAddress } from "../utils/builder";
+import { hexToBytes } from "../utils/encoding";
+
+export const resolveDataHash = (data: Data) => {
+  const plutusData = toPlutusData(data);
+  return plutusData.hash().toString();
+};
+
+export const resolveNativeScriptAddress = (
+  script: NativeScript,
+  networkId = 0,
+) => {
+  const nativeScript = toNativeScript(script);
+
+  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
+    hash: nativeScript.hash(),
+    type: Cardano.CredentialType.ScriptHash,
+  });
+
+  return enterpriseAddress.toAddress().toBech32();
+};
+
+export const resolveNativeScriptHash = (script: NativeScript) => {
+  return toNativeScript(script).hash().toString();
+};
+
+export const resolvePaymentKeyHash = (bech32: string) => {
+  try {
+    const paymentKeyHash = [
+      toBaseAddress(bech32)?.getPaymentCredential().hash,
+      toEnterpriseAddress(bech32)?.getPaymentCredential().hash,
+    ].find((kh) => kh !== undefined);
+
+    if (paymentKeyHash !== undefined) return paymentKeyHash.toString();
+
+    throw new Error(
+      `Couldn't resolve payment key hash from address: ${bech32}`,
+    );
+  } catch (error) {
+    throw new Error(
+      `An error occurred during resolvePaymentKeyHash: ${error}.`,
+    );
+  }
+};
+
+export const resolvePlutusScriptAddress = (
+  script: PlutusScript,
+  networkId = 0,
+) => {
+  const plutusScript = deserializePlutusScript(script.code, script.version);
+
+  const enterpriseAddress = EnterpriseAddress.fromCredentials(networkId, {
+    hash: plutusScript.hash(),
+    type: Cardano.CredentialType.ScriptHash,
+  });
+
+  return enterpriseAddress.toAddress().toBech32();
+};
+
+export const resolvePlutusScriptHash = (bech32: string) => {
+  try {
+    const enterpriseAddress = toEnterpriseAddress(bech32);
+    const scriptHash = enterpriseAddress?.getPaymentCredential().hash;
+
+    if (scriptHash !== undefined) return scriptHash.toString();
+
+    throw new Error(`Couldn't resolve script hash from address: ${bech32}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveScriptHash: ${error}.`);
+  }
+};
+
+export const resolvePoolId = (hash: string) => {
+  return Ed25519KeyHashHex(hash).toString();
+};
+
+export const resolvePrivateKey = (words: string[]) => {
+  return "not implemented";
+};
+
+export const resolveScriptRef = (script: PlutusScript | NativeScript) => {
+  return toScriptRef(script).toCbor().toString();
+};
+
+export const resolveRewardAddress = (bech32: string) => {
+  try {
+    const address = toAddress(bech32);
+    const baseAddress = toBaseAddress(bech32);
+    const stakeKeyHash = baseAddress?.getStakeCredential().hash;
+
+    if (stakeKeyHash !== undefined)
+      return buildRewardAddress(address.getNetworkId(), stakeKeyHash)
+        .toAddress()
+        .toBech32();
+
+    throw new Error(`Couldn't resolve reward address from address: ${bech32}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
+  }
+};
+
+export const resolveStakeKeyHash = (bech32: string) => {
+  try {
+    const stakeKeyHash = [
+      toBaseAddress(bech32)?.getStakeCredential().hash,
+      toRewardAddress(bech32)?.getPaymentCredential().hash,
+    ].find((kh) => kh !== undefined);
+
+    if (stakeKeyHash !== undefined) return stakeKeyHash.toString();
+
+    throw new Error(`Couldn't resolve stake key hash from address: ${bech32}`);
+  } catch (error) {
+    throw new Error(`An error occurred during resolveStakeKeyHash: ${error}.`);
+  }
+};
+
+export const resolveTxHash = (txHex: string) => {
+  const txBody = deserializeTx(txHex).body();
+  const hash = blake2b(blake2b.BYTES)
+    .update(hexToBytes(txBody.toCbor()))
+    .digest();
+  return Cardano.TransactionId.fromHexBlob(HexBlob.fromBytes(hash));
+};