@sign-global/tokentable-wallets 1.0.1 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @sign-global/tokentable-wallets
 
+## 1.2.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @sign-global/tokentable-core@1.2.0
+
+## 1.1.0
+
+### Minor Changes
+
+- feat: add Ledger wallet support and enhance signing functionality
+
 ## 1.0.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -11,11 +11,13 @@ import { Cluster } from '@solana/web3.js';
 declare enum ChainType {
     Evm = "evm",
     Ton = "ton",
-    Solana = "solana"
+    Solana = "solana",
+    Sui = "sui"
 }
 type ISignResult = {
     message: string;
     signature: string;
+    signedMessage?: string;
     [key: string]: any;
 } | undefined;
 

package/dist/index.d.ts

@@ -11,11 +11,13 @@ import { Cluster } from '@solana/web3.js';
 declare enum ChainType {
     Evm = "evm",
     Ton = "ton",
-    Solana = "solana"
+    Solana = "solana",
+    Sui = "sui"
 }
 type ISignResult = {
     message: string;
     signature: string;
+    signedMessage?: string;
     [key: string]: any;
 } | undefined;
 

package/dist/index.js

@@ -419,6 +419,343 @@ var import_wallet_adapter_wallets = require("@solana/wallet-adapter-wallets");
 var import_bs58 = __toESM(require("bs58"));
 var import_events3 = __toESM(require("events"));
 var import_tokentable_core3 = require("@sign-global/tokentable-core");
+
+// src/utils/ledger/adapter.ts
+var import_wallet_adapter_base2 = require("@solana/wallet-adapter-base");
+
+// src/utils/ledger/polyfills/Buffer.ts
+var import_buffer = require("buffer");
+if (typeof window !== "undefined" && window.Buffer === void 0) {
+  window.Buffer = import_buffer.Buffer;
+}
+
+// src/utils/ledger/util.ts
+var import_hw_transport = require("@ledgerhq/hw-transport");
+var import_wallet_adapter_base = require("@solana/wallet-adapter-base");
+var import_web3 = require("@solana/web3.js");
+function getDerivationPath(account, change) {
+  const length = account !== void 0 ? change === void 0 ? 3 : 4 : 2;
+  const derivationPath = Buffer.alloc(1 + length * 4);
+  let offset = derivationPath.writeUInt8(length, 0);
+  offset = derivationPath.writeUInt32BE(harden(44), offset);
+  offset = derivationPath.writeUInt32BE(harden(501), offset);
+  if (account !== void 0) {
+    offset = derivationPath.writeUInt32BE(harden(account), offset);
+    if (change !== void 0) {
+      derivationPath.writeUInt32BE(harden(change), offset);
+    }
+  }
+  return derivationPath;
+}
+var BIP32_HARDENED_BIT = 1 << 31 >>> 0;
+function harden(n) {
+  return (n | BIP32_HARDENED_BIT) >>> 0;
+}
+var INS_GET_VERSION = 4;
+var INS_GET_PUBKEY = 5;
+var INS_SIGN_MESSAGE = 6;
+var INS_SIGN_MESSAGE_OFFCHAIN = 7;
+var P1_NON_CONFIRM = 0;
+var P1_CONFIRM = 1;
+var P2_EXTEND = 1;
+var P2_MORE = 2;
+var MAX_PAYLOAD = 255;
+var LEDGER_CLA = 224;
+var OFFCM_MAX_LEDGER_LEN = 1212;
+var OFFCM_MAX_V0_LEN = 65515;
+var OffchainMessage = class _OffchainMessage {
+  version;
+  messageFormat;
+  message;
+  signerAddress;
+  /**
+   * Constructs a new OffchainMessage
+   * @param {version: number, messageFormat: number, message: string | Buffer} opts - Constructor parameters
+   */
+  constructor(opts) {
+    this.version = 0;
+    this.messageFormat = void 0;
+    this.message = void 0;
+    this.signerAddress = opts.signerAddress;
+    if (!opts) {
+      return;
+    }
+    if (opts.version) {
+      this.version = opts.version;
+    }
+    if (opts.messageFormat) {
+      this.messageFormat = opts.messageFormat;
+    }
+    if (opts.message) {
+      this.message = Buffer.from(opts.message);
+      if (this.version === 0) {
+        if (!this.messageFormat) {
+          this.messageFormat = _OffchainMessage.guessMessageFormat(this.message);
+        }
+      }
+    }
+  }
+  static guessMessageFormat(message) {
+    if (Object.prototype.toString.call(message) !== "[object Uint8Array]") {
+      return void 0;
+    }
+    if (message.length <= OFFCM_MAX_LEDGER_LEN) {
+      if (_OffchainMessage.isPrintableASCII(message)) {
+        return 0;
+      } else if (_OffchainMessage.isUTF8(message)) {
+        return 1;
+      }
+    } else if (message.length <= OFFCM_MAX_V0_LEN) {
+      if (_OffchainMessage.isUTF8(message)) {
+        return 2;
+      }
+    }
+    return void 0;
+  }
+  static isPrintableASCII(buffer) {
+    return buffer && buffer.every((element) => {
+      return element == 10 || element >= 32 && element <= 126;
+    });
+  }
+  static isUTF8(buffer) {
+    try {
+      new TextDecoder("utf8", { fatal: true }).decode(buffer);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isValid() {
+    if (this.version !== 0) {
+      return false;
+    }
+    if (!this.message) {
+      return false;
+    }
+    const format = _OffchainMessage.guessMessageFormat(this.message);
+    return format != null && format === this.messageFormat;
+  }
+  isLedgerSupported(allowBlindSigning) {
+    return this.isValid() && (this.messageFormat === 0 || this.messageFormat === 1 && allowBlindSigning);
+  }
+  serialize() {
+    if (!this.isValid()) {
+      throw new Error(`Invalid OffchainMessage: ${JSON.stringify(this)}`);
+    }
+    const signingDomain = Buffer.concat([Buffer.from([255]), Buffer.from("solana offchain")]);
+    const headerVersion = Buffer.alloc(1);
+    const applicationDomain = Buffer.alloc(32);
+    const messageFormat = Buffer.alloc(1);
+    const signerCount = Buffer.alloc(1);
+    signerCount.writeUInt8(1);
+    const messageLength = Buffer.alloc(2);
+    const messageBuffer = Buffer.from(this.message);
+    messageFormat.writeUInt8(this.messageFormat);
+    const signers = this.signerAddress.toBuffer();
+    messageLength.writeUInt16LE(messageBuffer.length);
+    return Buffer.concat([
+      signingDomain,
+      headerVersion,
+      applicationDomain,
+      messageFormat,
+      signerCount,
+      signers,
+      messageLength,
+      messageBuffer
+    ]);
+  }
+};
+async function getPublicKey(transport, derivationPath) {
+  const bytes = await send(transport, INS_GET_PUBKEY, P1_NON_CONFIRM, derivationPath);
+  return new import_web3.PublicKey(bytes);
+}
+async function signTransaction(transport, transaction, derivationPath) {
+  const paths = Buffer.alloc(1);
+  paths.writeUInt8(1, 0);
+  const message = (0, import_wallet_adapter_base.isVersionedTransaction)(transaction) ? transaction.message.serialize() : transaction.serializeMessage();
+  const data = Buffer.concat([paths, derivationPath, message]);
+  return await send(transport, INS_SIGN_MESSAGE, P1_CONFIRM, data);
+}
+async function signMessage2(transport, message, derivationPath) {
+  const paths = Buffer.alloc(1);
+  paths.writeUInt8(1, 0);
+  const data = Buffer.concat([paths, derivationPath, message]);
+  return await send(transport, INS_SIGN_MESSAGE_OFFCHAIN, P1_CONFIRM, data);
+}
+async function getAppConfiguration(transport) {
+  const [blindSigningEnabled, pubKeyDisplayMode, major, minor, patch] = await send(
+    transport,
+    INS_GET_VERSION,
+    P1_NON_CONFIRM,
+    Buffer.alloc(0)
+  );
+  return {
+    blindSigningEnabled: Boolean(blindSigningEnabled),
+    pubKeyDisplayMode,
+    version: `${major}.${minor}.${patch}`
+  };
+}
+async function send(transport, instruction, p1, data) {
+  let p2 = 0;
+  let offset = 0;
+  if (data.length > MAX_PAYLOAD) {
+    while (data.length - offset > MAX_PAYLOAD) {
+      const buffer2 = data.slice(offset, offset + MAX_PAYLOAD);
+      const response2 = await transport.send(LEDGER_CLA, instruction, p1, p2 | P2_MORE, buffer2);
+      if (response2.length !== 2) throw new import_hw_transport.TransportStatusError(import_hw_transport.StatusCodes.INCORRECT_DATA);
+      p2 |= P2_EXTEND;
+      offset += MAX_PAYLOAD;
+    }
+  }
+  const buffer = data.slice(offset);
+  const response = await transport.send(LEDGER_CLA, instruction, p1, p2, buffer);
+  return response.slice(0, response.length - 2);
+}
+
+// src/utils/ledger/adapter.ts
+var LedgerWalletName = "Ledger";
+var LedgerWalletAdapter = class extends import_wallet_adapter_base2.BaseSignerWalletAdapter {
+  name = LedgerWalletName;
+  url = "https://ledger.com";
+  icon = "data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzUgMzUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGcgZmlsbD0iI2ZmZiI+PHBhdGggZD0ibTIzLjU4OCAwaC0xNnYyMS41ODNoMjEuNnYtMTZhNS41ODUgNS41ODUgMCAwIDAgLTUuNi01LjU4M3oiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUuNzM5KSIvPjxwYXRoIGQ9Im04LjM0MiAwaC0yLjc1N2E1LjU4NSA1LjU4NSAwIDAgMCAtNS41ODUgNS41ODV2Mi43NTdoOC4zNDJ6Ii8+PHBhdGggZD0ibTAgNy41OWg4LjM0MnY4LjM0MmgtOC4zNDJ6IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIDUuNzM5KSIvPjxwYXRoIGQ9Im0xNS4xOCAyMy40NTFoMi43NTdhNS41ODUgNS41ODUgMCAwIDAgNS41ODUtNS42di0yLjY3MWgtOC4zNDJ6IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMS40NzggMTEuNDc4KSIvPjxwYXRoIGQ9Im03LjU5IDE1LjE4aDguMzQydjguMzQyaC04LjM0MnoiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUuNzM5IDExLjQ3OCkiLz48cGF0aCBkPSJtMCAxNS4xOHYyLjc1N2E1LjU4NSA1LjU4NSAwIDAgMCA1LjU4NSA1LjU4NWgyLjc1N3YtOC4zNDJ6IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIDExLjQ3OCkiLz48L2c+PC9zdmc+";
+  supportedTransactionVersions = /* @__PURE__ */ new Set(["legacy", 0]);
+  _derivationPath;
+  _connecting;
+  _transport;
+  _publicKey;
+  _readyState = typeof window === "undefined" || typeof document === "undefined" || typeof navigator === "undefined" || !navigator.hid ? import_wallet_adapter_base2.WalletReadyState.Unsupported : import_wallet_adapter_base2.WalletReadyState.Loadable;
+  constructor(config = {}) {
+    super();
+    this._derivationPath = config.derivationPath || getDerivationPath(0, 0);
+    this._connecting = false;
+    this._transport = null;
+    this._publicKey = null;
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  get connecting() {
+    return this._connecting;
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  async connect() {
+    try {
+      if (this.connected || this.connecting) return;
+      if (this._readyState !== import_wallet_adapter_base2.WalletReadyState.Loadable) throw new import_wallet_adapter_base2.WalletNotReadyError();
+      this._connecting = true;
+      let TransportWebHIDClass;
+      try {
+        TransportWebHIDClass = (await import("@ledgerhq/hw-transport-webhid")).default;
+      } catch (error) {
+        throw new import_wallet_adapter_base2.WalletLoadError(error?.message, error);
+      }
+      let transport;
+      try {
+        transport = await TransportWebHIDClass.create();
+      } catch (error) {
+        throw new import_wallet_adapter_base2.WalletConnectionError(error?.message, error);
+      }
+      let publicKey;
+      try {
+        publicKey = await getPublicKey(transport, this._derivationPath);
+      } catch (error) {
+        throw new import_wallet_adapter_base2.WalletPublicKeyError(error?.message, error);
+      }
+      transport.on("disconnect", this._disconnected);
+      this._transport = transport;
+      this._publicKey = publicKey;
+      this.emit("connect", publicKey);
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    } finally {
+      this._connecting = false;
+    }
+  }
+  async disconnect() {
+    const transport = this._transport;
+    if (transport) {
+      transport.off("disconnect", this._disconnected);
+      this._transport = null;
+      this._publicKey = null;
+      try {
+        await transport.close();
+      } catch (error) {
+        this.emit("error", new import_wallet_adapter_base2.WalletDisconnectionError(error?.message, error));
+      }
+    }
+    this.emit("disconnect");
+  }
+  async signTransaction(transaction) {
+    try {
+      const transport = this._transport;
+      const publicKey = this._publicKey;
+      if (!transport || !publicKey) throw new import_wallet_adapter_base2.WalletNotConnectedError();
+      try {
+        const signature = await signTransaction(transport, transaction, this._derivationPath);
+        transaction.addSignature(publicKey, signature);
+      } catch (error) {
+        throw new import_wallet_adapter_base2.WalletSignTransactionError(error?.message, error);
+      }
+      return transaction;
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  async signMessage(message) {
+    try {
+      try {
+        const transport = this._transport;
+        const publicKey = this._publicKey;
+        if (!transport || !publicKey) throw new import_wallet_adapter_base2.WalletNotConnectedError();
+        const appConfig = await getAppConfiguration(transport);
+        const [major, minor] = appConfig.version.split(".").map(Number);
+        if (major < 1 || major === 1 && minor < 8) {
+          throw new import_wallet_adapter_base2.WalletSignMessageError("Signing off-chain messages requires Solana Ledger App 1.8.0 or later");
+        }
+        const offchainMessage = new OffchainMessage({
+          message: Buffer.from(message.buffer),
+          signerAddress: publicKey
+        });
+        if (!offchainMessage.isLedgerSupported(appConfig.blindSigningEnabled)) {
+          if (!offchainMessage.isValid()) {
+            throw new import_wallet_adapter_base2.WalletSignMessageError("Message is not valid for signing.");
+          } else if (offchainMessage.messageFormat === 1 && !appConfig.blindSigningEnabled) {
+            throw new import_wallet_adapter_base2.WalletSignMessageError(
+              "Message contains non-ASCII characters and requires blind signing to be enabled on your Ledger device."
+            );
+          } else if (offchainMessage.messageFormat === 2) {
+            throw new import_wallet_adapter_base2.WalletSignMessageError("Message is too long to be signed on Ledger device.");
+          } else {
+            throw new import_wallet_adapter_base2.WalletSignMessageError("Message format is not supported by Ledger device.");
+          }
+        }
+        const signature = await signMessage2(transport, offchainMessage.serialize(), this._derivationPath);
+        return { signature: new Uint8Array(signature), signedMessage: offchainMessage.serialize() };
+      } catch (error) {
+        throw new import_wallet_adapter_base2.WalletSignMessageError(error?.message, error);
+      }
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  _disconnected = () => {
+    const transport = this._transport;
+    if (transport) {
+      transport.off("disconnect", this._disconnected);
+      this._transport = null;
+      this._publicKey = null;
+      this.emit("error", new import_wallet_adapter_base2.WalletDisconnectedError());
+      this.emit("disconnect");
+    }
+  };
+};
+
+// src/providers/solana/index.tsx
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var solStore = {
   connectModal: null,
@@ -447,10 +784,12 @@ var SolWallet = class extends WalletBase {
     try {
       const provider = solStore.account;
       const encodedMessage = new TextEncoder().encode(message);
-      const signedMessage = await provider.signMessage?.(encodedMessage);
+      const result = await provider.signMessage?.(encodedMessage);
+      const { signature, signedMessage } = result instanceof Uint8Array ? { signature: result, signedMessage: "" } : result;
       return {
         message,
-        signature: import_bs58.default.encode(signedMessage)
+        signature: import_bs58.default.encode(signature),
+        signedMessage: signedMessage instanceof Uint8Array ? import_bs58.default.encode(signedMessage) : ""
       };
     } catch (error) {
       console.error(error);
@@ -458,30 +797,40 @@ var SolWallet = class extends WalletBase {
     }
   }
   signin(statement, prepare = true) {
-    return new Promise((resolve) => {
-      const signCallback = (data) => {
-        this.publicKey = data.publicKey?.toString();
-        this.address = this.publicKey;
-        this.chainId = 1;
-        let fullMessage = statement;
-        if (prepare) {
-          const msg = prepareSignMessage({ statement, chainId: "1", address: this.address });
-          fullMessage = get4361Message(msg);
+    return new Promise((resolve, reject) => {
+      try {
+        const signCallback = async (data) => {
+          try {
+            this.publicKey = data.publicKey?.toString();
+            this.address = this.publicKey;
+            this.chainId = 1;
+            let fullMessage = statement;
+            if (prepare) {
+              const msg = prepareSignMessage({ statement, chainId: "1", address: this.address });
+              fullMessage = get4361Message(msg);
+            }
+            const res = await this.sign(fullMessage);
+            resolve(res);
+          } catch (error) {
+            console.error("Error in signCallback:", error);
+            reject(error);
+          }
+        };
+        if (this.isConnected) {
+          signCallback(solStore.account);
+          return;
         }
-        const res = this.sign(fullMessage);
-        resolve(res);
-      };
-      if (this.isConnected) {
-        signCallback(solStore.account);
-        return;
+        solStore.counter++;
+        this.connect();
+        const eventKey = getEventKey3();
+        eventBus3.once(eventKey, (data) => {
+          console.log("listen event key success, event key = %s, data = %j", eventKey, data);
+          signCallback(data);
+        });
+      } catch (error) {
+        console.error("Error in signin:", error);
+        reject(error);
       }
-      solStore.counter++;
-      this.connect();
-      const eventKey = getEventKey3();
-      eventBus3.once(eventKey, (data) => {
-        console.log("listen event key success, event key = %s, data = %j", eventKey, data);
-        signCallback(data);
-      });
     });
   }
 };
@@ -507,7 +856,13 @@ var SolanaProvider = ({
 }) => {
   const endpoint = (0, import_tokentable_core3.clusterApiUrl)(cluster ? cluster : "mainnet-beta");
   const defaultWallets = (0, import_react3.useMemo)(
-    () => [new import_wallet_adapter_wallets.PhantomWalletAdapter(), new import_wallet_adapter_wallets.TrustWalletAdapter(), new import_wallet_adapter_wallets.LedgerWalletAdapter()],
+    () => [
+      new import_wallet_adapter_wallets.PhantomWalletAdapter(),
+      new import_wallet_adapter_wallets.TrustWalletAdapter(),
+      new LedgerWalletAdapter({
+        derivationPath: getDerivationPath(0)
+      })
+    ],
     []
   );
   const onError = (0, import_react3.useCallback)((error) => {