@sundaeswap/wallet-lite 0.0.87 → 0.0.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/wallet-lite",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -22,7 +22,7 @@
     "LICENSE.md"
   ],
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "scripts": {
     "clean": "rm -rf ./dist",
@@ -36,6 +36,7 @@
   },
   "dependencies": {
     "@babel/cli": "^7.24.7",
+    "@blockfrost/blockfrost-js": "^6.0.0",
     "@fabianbormann/cardano-peer-connect": "^1.2.17",
     "@koralabs/adahandle-sdk": "^1.5.5",
     "@sundaeswap/asset": "^1.0.7",

package/src/@types/observer.ts

@@ -4,6 +4,7 @@ import type { DAppPeerConnect } from "@fabianbormann/cardano-peer-connect";
 import type { DAppPeerConnectParameters } from "@fabianbormann/cardano-peer-connect/dist/src/types.js";
 import type { IAssetAmountMetadata } from "@sundaeswap/asset";
 
+import { ReadOnlyProvider } from "src/classes/ReadOnlyProvider.Abstract.class.js";
 import { WalletAssetMap } from "../classes/WalletAssetMap.class.js";
 import { WalletBalanceMap } from "../classes/WalletBalanceMap.class.js";
 import { isAdaAsset, normalizeAssetIdWithDot } from "../utils/assets.js";
@@ -54,6 +55,7 @@ export interface IResolvedWalletObserverOptions<
   persistence: boolean;
   peerConnectArgs: DAppPeerConnectParameters;
   connectTimeout: number;
+  readOnlyProvider?: ReadOnlyProvider;
   debug: boolean;
 }
 

package/src/classes/ReadOnlyApi.class.ts

@@ -0,0 +1,64 @@
+import { Cardano } from "@cardano-sdk/core";
+import { Cip30WalletApi } from "@cardano-sdk/dapp-connector";
+
+import { ReadOnlyProvider } from "./ReadOnlyProvider.Abstract.class.js";
+
+export class ReadOnlyApi implements Cip30WalletApi {
+  address: string;
+  network: 0 | 1;
+  provider: ReadOnlyProvider;
+
+  constructor(address: string, network: 0 | 1, provider: ReadOnlyProvider) {
+    this.address = address;
+    this.provider = provider;
+    this.network = network;
+  }
+
+  getBalance = async () => {
+    return this.provider.getBalance(this.address, this.network);
+  };
+
+  getChangeAddress = async () => {
+    return Cardano.Address.fromBech32(this.address).toBytes();
+  };
+
+  getCollateral = async () => {
+    return [];
+  };
+
+  getExtensions = async () => {
+    return [];
+  };
+
+  getNetworkId = async () => {
+    return this.network;
+  };
+
+  getRewardAddresses = async () => {
+    return [];
+  };
+
+  getUnusedAddresses = async () => {
+    return [];
+  };
+
+  getUsedAddresses = async () => {
+    return [];
+  };
+
+  getUtxos = async () => {
+    return this.provider.getUtxos(this.address, this.network);
+  };
+
+  signData = async () => {
+    throw new Error("not implemented");
+  };
+
+  signTx = async () => {
+    throw new Error("not implemented");
+  };
+
+  submitTx = async () => {
+    throw new Error("not implemented");
+  };
+}

package/src/classes/ReadOnlyProvider.Abstract.class.ts

@@ -0,0 +1,4 @@
+export abstract class ReadOnlyProvider {
+  abstract getBalance: (address: string, network: 0 | 1) => Promise<string>;
+  abstract getUtxos: (address: string, network: 0 | 1) => Promise<string[]>;
+}

package/src/classes/ReadOnlyProvider.Blockfrost.class.ts

@@ -0,0 +1,87 @@
+import type { BlockFrostAPI, Responses } from "@blockfrost/blockfrost-js";
+import { Cardano, Serialization } from "@cardano-sdk/core";
+import { Hash32ByteBase16 } from "@cardano-sdk/crypto";
+
+import { HexBlob } from "@cardano-sdk/util";
+import { ReadOnlyProvider } from "./ReadOnlyProvider.Abstract.class.js";
+
+export class ReadOnlyBlockfrostProvider implements ReadOnlyProvider {
+  blockfrostProjectId: string;
+  api?: BlockFrostAPI;
+
+  constructor(blockfrostProjectId: string) {
+    this.blockfrostProjectId = blockfrostProjectId;
+  }
+
+  async getBalance(address: string, network: 0 | 1) {
+    const result: Responses["address_content"] = await fetch(
+      `https://cardano-${network ? "mainnet" : "preview"}.blockfrost.io/api/v0/addresses/${address}`,
+      {
+        headers: {
+          project_id: this.blockfrostProjectId,
+        },
+      },
+    ).then((res) => res.json());
+
+    // Build our value.
+    const value = this.__getValueFromAmount(result.amount);
+
+    // Return the cbor.
+    return value.toCbor();
+  }
+
+  async getUtxos(address: string, network: 0 | 1) {
+    const result: Responses["address_utxo_content"] = await fetch(
+      `https://cardano-${network ? "mainnet" : "preview"}.blockfrost.io/api/v0/addresses/${address}/utxos`,
+      {
+        headers: {
+          project_id: this.blockfrostProjectId,
+        },
+      },
+    ).then((res) => res.json());
+
+    const formatted = result.map((r) => {
+      return Serialization.TransactionUnspentOutput.fromCore([
+        Serialization.TransactionInput.fromCore({
+          index: r.output_index,
+          txId: Cardano.TransactionId(r.tx_hash),
+        }).toCore(),
+        Serialization.TransactionOutput.fromCore({
+          address: Cardano.PaymentAddress(r.address),
+          value: this.__getValueFromAmount(r.amount).toCore(),
+          datum: r.inline_datum
+            ? Serialization.PlutusData.fromCbor(
+                HexBlob(r.inline_datum),
+              ).toCore()
+            : undefined,
+          datumHash: r.data_hash ? Hash32ByteBase16(r.data_hash) : undefined,
+        }).toCore(),
+      ]).toCbor();
+    });
+
+    return formatted;
+  }
+
+  private __getValueFromAmount(amount: { unit: string; quantity: string }[]) {
+    const lovelace = amount.find((a) => a.unit === "lovelace");
+    const assets = amount.filter((a) => a.unit !== "lovelace");
+
+    // Build our token map.
+    const tokenMap = new Map<Cardano.AssetId, bigint>();
+    assets.forEach((asset) => {
+      const matchingEntry = tokenMap.get(Cardano.AssetId(asset.unit)) || 0n;
+      tokenMap.set(
+        Cardano.AssetId(asset.unit),
+        BigInt(asset.quantity) + matchingEntry,
+      );
+    });
+
+    // Build our value.
+    const value = Serialization.Value.fromCore({
+      coins: BigInt(lovelace?.quantity || 0),
+      assets: tokenMap,
+    });
+
+    return value;
+  }
+}

package/src/classes/WalletObserver.class.ts

@@ -23,6 +23,7 @@ import {
   getCardanoUtil,
   getPeerConnect,
 } from "../utils/getLibs.js";
+import { ReadOnlyApi } from "./ReadOnlyApi.class.js";
 import { WalletBalanceMap } from "./WalletBalanceMap.class.js";
 import { WalletObserverEvent } from "./WalletObserverEvent.js";
 import { WalletObserverUtils } from "./WalletObserverUtils.class.js";
@@ -227,6 +228,22 @@ export class WalletObserver<
     let attempts = 0;
     let shouldContinue = true;
 
+    if (selectedWallet.startsWith("addr")) {
+      if (!this._options.readOnlyProvider) {
+        throw new Error(
+          "You must provide a ReadOnlyProvider when connecting with a read-only address.",
+        );
+      }
+
+      this.api = new ReadOnlyApi(
+        selectedWallet,
+        selectedWallet.startsWith("addr_test") ? 0 : 1,
+        this._options.readOnlyProvider,
+      );
+      this.network = await this.api.getNetworkId();
+      return this.api;
+    }
+
     while (shouldContinue) {
       if (attempts === 10) {
         throw new Error(
@@ -296,7 +313,14 @@ export class WalletObserver<
       this.peerConnectInstance?.shutdownServer();
     }
 
-    while (typeof extensionObject === "undefined") {
+    while (
+      typeof extensionObject === "undefined" &&
+      !extension.startsWith("addr")
+    ) {
+      if (this._options.debug) {
+        console.warn(`Could not find extension: ${extension}. Trying again...`);
+      }
+
       if (attempts === 40) {
         break;
       }
@@ -308,9 +332,11 @@ export class WalletObserver<
       attempts++;
     }
 
-    if (!extensionObject) {
+    if (!extensionObject && !extension.startsWith("addr")) {
       this.dispatch(EWalletObserverEvents.CONNECT_WALLET_END);
-      throw new Error("Wallet extension not found in the global context.");
+      throw new Error(
+        `Could not find extension (${extension}) in the global context.`,
+      );
     }
 
     this.activeWallet = extension;

package/src/classes/__tests__/WalletObserver.test.ts

@@ -47,7 +47,7 @@ describe("WalletObserver", async () => {
         new WalletObserver({
           connectTimeout: 10,
         }).connectWallet("flint"),
-      ).toThrowError("Wallet extension not found in the global context.");
+      ).toThrowError("Could not find extension (flint) in the global context.");
     });
   });
 

package/src/classes/index.ts

@@ -1,3 +1,5 @@
+export { ReadOnlyProvider } from "./ReadOnlyProvider.Abstract.class.js";
+export { ReadOnlyBlockfrostProvider } from "./ReadOnlyProvider.Blockfrost.class.js";
 export { WalletAssetMap } from "./WalletAssetMap.class.js";
 export { WalletBalanceMap } from "./WalletBalanceMap.class.js";
 export { WalletObserver } from "./WalletObserver.class.js";