@cubist-labs/cubesigner-sdk-viem 0.4.183-0

package/README.md

@@ -0,0 +1,51 @@
+# CubeSigner Plugin for Viem
+
+This package exposes a single `CubeSignerSource` class which implements
+a custom source in Viem, backed by CubeSigner.
+
+## Simple example usage
+
+```typescript
+import { type CustomSource, createWalletClient, http, publicActions } from "viem";
+import { CubeSignerClient } from "@cubist-labs/cubesigner-sdk";
+import { CubeSignerSource } from "@cubist-labs/cubesigner-sdk-viem";
+import { sepolia } from "viem/chains";
+import { toAccount } from "viem/accounts";
+
+const client = await CubeSignerClient.create(...); // must have permissions to sign with `key`
+const key = ...; // A CubeSigner key object or a string of an address in your org
+const chain = sepolia; // use an object from "viem/chains"
+
+const account = toAccount(new CubeSignerSource(key, client) as CustomSource);
+
+// Create a WalletClient to perform actions
+const walletClient = createWalletClient({
+  account,
+  chain,
+  transport: http(), // uses Viem's default RPC provider
+}).extend(publicActions);
+
+// Sign transaction as usual:
+const tx = await walletClient.prepareTransactionRequest({
+  to: "0x96be1e4c198ecb1a55e769f653b1934950294f19",
+  value: 0n,
+});
+
+const signature = await walletClient.signTransaction(tx);
+...
+```
+
+Check out our [Viem example](../../examples/viem/src/index.ts) or the unit tests
+in the `test` folder for more examples.
+
+The [@cubist-labs/cubesigner-sdk](https://www.npmjs.com/package/@cubist-labs/cubesigner-sdk) contains more details on how to create signer sessions.
+
+## Supported Transactions
+
+Please note that CubeSigner only supports legacy or EIP-1559 EVM
+transactions with an explicitly defined `type` field. It's recommended to use
+`prepareTransactionRequest` before signing to fill this field.
+
+Transactions must take place on a specific chain---either use a client which
+holds a specific chain, or ensure your transaction has the `chainId` field
+defined.

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import { type Address, type CustomSource } from "viem";
+import { type CubeSignerClient, type EvmSignerOptions, type Key } from "@cubist-labs/cubesigner-sdk";
+/**
+ * A class to wrap a CubeSigner key and client into a Viem {@link CustomSource}.
+ * Use Viem's `toAccount` to convert this to a Viem Account.
+ */
+export declare class CubeSignerSource implements CustomSource {
+    #private;
+    /** The address the wallet is associated with. */
+    readonly address: Address;
+    /**
+     * Construct a Viem {@link CustomSource} around a CubeSigner key and client.
+     * Use Viem's `toAccount` to convert this to a Viem Account.
+     *
+     * @param address The EVM address this wallet is associated with
+     * @param client The session used for signing. Must have necessary scopes.
+     * @param options MFA options for the client to respect
+     * @throws {Error} if the address is not a valid EVM address
+     */
+    constructor(address: Key | string, client: CubeSignerClient, options?: EvmSignerOptions);
+    /**
+     * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip191Signing"` policy attached.
+     *
+     * @param root Object around the message
+     * @param root.message The message to sign
+     * @returns The signature
+     */
+    signMessage: CustomSource["signMessage"];
+    /**
+     * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.
+     * The key (for this session) must have the `"AllowRawBlobSigning"` or
+     * `"AllowEip712Signing"` policy attached.
+     * `chainId` must be specified within the `domain`.
+     *
+     * @param parameters Typed data
+     * @returns signature for the typed data
+     */
+    signTypedData: CustomSource["signTypedData"];
+    /**
+     * It is recommended to use `prepareTransactionRequest` on your request
+     * before calling this function.
+     *
+     * Sign a transaction. This method will block if the key requires MFA approval.
+     * `type` and `chainId` must be defined. Only supports type "legacy" or "eip1559".
+     *
+     * @param transaction The transaction to sign
+     * @param options Contains an optional custom serializer
+     * @returns Signed transaction
+     * @throws {Error} if transaction.type isn't "legacy" or "eip1559", or if "chainId" isn't specified
+     */
+    signTransaction: CustomSource["signTransaction"];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EAUlB,MAAM,MAAM,CAAC;AACd,OAAO,EACL,KAAK,gBAAgB,EAIrB,KAAK,gBAAgB,EACrB,KAAK,GAAG,EACT,MAAM,6BAA6B,CAAC;AAErC;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,YAAY;;IAInD,iDAAiD;IACjD,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC;;;;;;;;OAQG;gBACS,OAAO,EAAE,GAAG,GAAG,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAYvF;;;;;;;;OAQG;IACI,WAAW,EAAE,YAAY,CAAC,aAAa,CAAC,CAa7C;IAEF;;;;;;;;OAQG;IACI,aAAa,EAAE,YAAY,CAAC,eAAe,CAAC,CAYjD;IAEF;;;;;;;;;;;OAWG;IACI,eAAe,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAsBrD;CACH"}

package/dist/index.js

@@ -0,0 +1,129 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CubeSignerSource_signer;
+import { bytesToHex, formatTransactionRequest, getAddress, isHex, parseTransaction, serializeTransaction, stringToHex, } from "viem";
+import { EvmSigner, } from "@cubist-labs/cubesigner-sdk";
+/**
+ * A class to wrap a CubeSigner key and client into a Viem {@link CustomSource}.
+ * Use Viem's `toAccount` to convert this to a Viem Account.
+ */
+export class CubeSignerSource {
+    /**
+     * Construct a Viem {@link CustomSource} around a CubeSigner key and client.
+     * Use Viem's `toAccount` to convert this to a Viem Account.
+     *
+     * @param address The EVM address this wallet is associated with
+     * @param client The session used for signing. Must have necessary scopes.
+     * @param options MFA options for the client to respect
+     * @throws {Error} if the address is not a valid EVM address
+     */
+    constructor(address, client, options) {
+        /** The internal CubeSigner signer used. */
+        _CubeSignerSource_signer.set(this, void 0);
+        /**
+         * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.
+         * The key (for this session) must have the `"AllowRawBlobSigning"` or
+         * `"AllowEip191Signing"` policy attached.
+         *
+         * @param root Object around the message
+         * @param root.message The message to sign
+         * @returns The signature
+         */
+        this.signMessage = async ({ message }) => {
+            let hex;
+            if (typeof message === "string") {
+                hex = stringToHex(message);
+            }
+            else if (isHex(message.raw)) {
+                hex = message.raw;
+            }
+            else {
+                hex = bytesToHex(message.raw);
+            }
+            const signature = await __classPrivateFieldGet(this, _CubeSignerSource_signer, "f").signEip191({ data: hex });
+            return ensureHex(signature);
+        };
+        /**
+         * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.
+         * The key (for this session) must have the `"AllowRawBlobSigning"` or
+         * `"AllowEip712Signing"` policy attached.
+         * `chainId` must be specified within the `domain`.
+         *
+         * @param parameters Typed data
+         * @returns signature for the typed data
+         */
+        this.signTypedData = async (parameters) => {
+            assert(parameters.domain, "`domain` must be defined");
+            const castedParameters = parameters;
+            assert(castedParameters.domain.chainId, "`domain.chainId` must be defined");
+            const signature = await __classPrivateFieldGet(this, _CubeSignerSource_signer, "f").signEip712({
+                chain_id: Number(castedParameters.domain.chainId),
+                typed_data: castedParameters,
+            });
+            return ensureHex(signature);
+        };
+        /**
+         * It is recommended to use `prepareTransactionRequest` on your request
+         * before calling this function.
+         *
+         * Sign a transaction. This method will block if the key requires MFA approval.
+         * `type` and `chainId` must be defined. Only supports type "legacy" or "eip1559".
+         *
+         * @param transaction The transaction to sign
+         * @param options Contains an optional custom serializer
+         * @returns Signed transaction
+         * @throws {Error} if transaction.type isn't "legacy" or "eip1559", or if "chainId" isn't specified
+         */
+        this.signTransaction = async (transaction, options) => {
+            assert(transaction.type === "legacy" || transaction.type === "eip1559", `Unsupported transaction type '${transaction.type}', CubeSigner only supports type 'legacy' or 'eip1559'")}'`);
+            assert(transaction.chainId, "`chainId` must be defined");
+            const formatted = formatTransactionRequest(transaction);
+            const rlpSignedTransaction = await __classPrivateFieldGet(this, _CubeSignerSource_signer, "f").signTransaction({
+                chain_id: transaction.chainId,
+                tx: formatted,
+            });
+            // CubeSigner returns an RLP-encoded transaction. Since Viem allows users to pass a custom serializer, we will
+            // now unserialize and reserialize with Viem's serializer.
+            const { r, s, v, yParity, ...parsedTransaction } = parseTransaction(ensureHex(rlpSignedTransaction));
+            const serializer = options?.serializer ?? serializeTransaction;
+            return await serializer(parsedTransaction, { r, s, v, yParity });
+        };
+        __classPrivateFieldSet(this, _CubeSignerSource_signer, new EvmSigner(address, client, options), "f");
+        // NOTE: `getAddress` will checksum the address and throw if it's an invalid EVM address.
+        this.address = getAddress(__classPrivateFieldGet(this, _CubeSignerSource_signer, "f").address);
+        // Scope these functions to properly resolve `this`
+        this.signMessage = this.signMessage.bind(this);
+        this.signTransaction = this.signTransaction.bind(this);
+        this.signTypedData = this.signTypedData.bind(this);
+    }
+}
+_CubeSignerSource_signer = new WeakMap();
+/**
+ * @param input A hex string
+ * @returns the input, type narrowed to Hex
+ * @throws {Error} if input is not Hex
+ */
+function ensureHex(input) {
+    assert(isHex(input), `${input} is not hex`);
+    return input;
+}
+/**
+ * @param value A value that is expected to be truthy
+ * @param message The error message if the value is falsy
+ * @throws {Error} if value is not truthy
+ */
+function assert(value, message) {
+    if (!value) {
+        throw new Error(message);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAKL,UAAU,EACV,wBAAwB,EACxB,UAAU,EACV,KAAK,EACL,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,GACZ,MAAM,MAAM,CAAC;AACd,OAAO,EAIL,SAAS,GAGV,MAAM,6BAA6B,CAAC;AAErC;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IAO3B;;;;;;;;OAQG;IACH,YAAY,OAAqB,EAAE,MAAwB,EAAE,OAA0B;QAfvF,2CAA2C;QAClC,2CAAmB;QA0B5B;;;;;;;;WAQG;QACI,gBAAW,GAAgC,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;YACtE,IAAI,GAAG,CAAC;YACR,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAChC,GAAG,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YAC7B,CAAC;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAChC,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,uBAAA,IAAI,gCAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;YAE/D,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF;;;;;;;;WAQG;QACI,kBAAa,GAAkC,KAAK,EAAE,UAAU,EAAE,EAAE;YACzE,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;YAEtD,MAAM,gBAAgB,GAAG,UAA6C,CAAC;YACvE,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;YAE5E,MAAM,SAAS,GAAG,MAAM,uBAAA,IAAI,gCAAQ,CAAC,UAAU,CAAC;gBAC9C,QAAQ,EAAE,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC;gBACjD,UAAU,EAAE,gBAAgB;aAC7B,CAAC,CAAC;YAEH,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF;;;;;;;;;;;WAWG;QACI,oBAAe,GAAoC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE;YACvF,MAAM,CACJ,WAAW,CAAC,IAAI,KAAK,QAAQ,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS,EAC/D,iCAAiC,WAAW,CAAC,IAAI,4DAA4D,CAC9G,CAAC;YAEF,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,2BAA2B,CAAC,CAAC;YAEzD,MAAM,SAAS,GAAG,wBAAwB,CAAC,WAAW,CAAC,CAAC;YACxD,MAAM,oBAAoB,GAAG,MAAM,uBAAA,IAAI,gCAAQ,CAAC,eAAe,CAAC;gBAC9D,QAAQ,EAAE,WAAW,CAAC,OAAO;gBAC7B,EAAE,EAAE,SAAiC;aACtC,CAAC,CAAC;YAEH,8GAA8G;YAC9G,0DAA0D;YAC1D,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,iBAAiB,EAAE,GAAG,gBAAgB,CACjE,SAAS,CAAC,oBAAoB,CAAC,CAChC,CAAC;YACF,MAAM,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,oBAAoB,CAAC;YAE/D,OAAO,MAAM,UAAU,CAAC,iBAAiB,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAe,CAAC,CAAC;QAChF,CAAC,CAAC;QA5FA,uBAAA,IAAI,4BAAW,IAAI,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,MAAA,CAAC;QAEvD,yFAAyF;QACzF,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,uBAAA,IAAI,gCAAQ,CAAC,OAAO,CAAC,CAAC;QAEhD,mDAAmD;QACnD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;CAoFF;;AAED;;;;GAIG;AACH,SAAS,SAAS,CAAC,KAAa;IAC9B,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,aAAa,CAAC,CAAC;IAC5C,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAS,MAAM,CAAC,KAAc,EAAE,OAAe;IAC7C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC","sourcesContent":["import {\n  type Address,\n  type CustomSource,\n  type Hex,\n  type Signature,\n  bytesToHex,\n  formatTransactionRequest,\n  getAddress,\n  isHex,\n  parseTransaction,\n  serializeTransaction,\n  stringToHex,\n} from \"viem\";\nimport {\n  type CubeSignerClient,\n  type Eip712SignRequest,\n  type EvmSignRequest,\n  EvmSigner,\n  type EvmSignerOptions,\n  type Key,\n} from \"@cubist-labs/cubesigner-sdk\";\n\n/**\n * A class to wrap a CubeSigner key and client into a Viem {@link CustomSource}.\n * Use Viem's `toAccount` to convert this to a Viem Account.\n */\nexport class CubeSignerSource implements CustomSource {\n  /** The internal CubeSigner signer used. */\n  readonly #signer: EvmSigner;\n\n  /** The address the wallet is associated with. */\n  public readonly address: Address;\n\n  /**\n   * Construct a Viem {@link CustomSource} around a CubeSigner key and client.\n   * Use Viem's `toAccount` to convert this to a Viem Account.\n   *\n   * @param address The EVM address this wallet is associated with\n   * @param client The session used for signing. Must have necessary scopes.\n   * @param options MFA options for the client to respect\n   * @throws {Error} if the address is not a valid EVM address\n   */\n  constructor(address: Key | string, client: CubeSignerClient, options?: EvmSignerOptions) {\n    this.#signer = new EvmSigner(address, client, options);\n\n    // NOTE: `getAddress` will checksum the address and throw if it's an invalid EVM address.\n    this.address = getAddress(this.#signer.address);\n\n    // Scope these functions to properly resolve `this`\n    this.signMessage = this.signMessage.bind(this);\n    this.signTransaction = this.signTransaction.bind(this);\n    this.signTypedData = this.signTypedData.bind(this);\n  }\n\n  /**\n   * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` or\n   * `\"AllowEip191Signing\"` policy attached.\n   *\n   * @param root Object around the message\n   * @param root.message The message to sign\n   * @returns The signature\n   */\n  public signMessage: CustomSource[\"signMessage\"] = async ({ message }) => {\n    let hex;\n    if (typeof message === \"string\") {\n      hex = stringToHex(message);\n    } else if (isHex(message.raw)) {\n      hex = message.raw;\n    } else {\n      hex = bytesToHex(message.raw);\n    }\n\n    const signature = await this.#signer.signEip191({ data: hex });\n\n    return ensureHex(signature);\n  };\n\n  /**\n   * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.\n   * The key (for this session) must have the `\"AllowRawBlobSigning\"` or\n   * `\"AllowEip712Signing\"` policy attached.\n   * `chainId` must be specified within the `domain`.\n   *\n   * @param parameters Typed data\n   * @returns signature for the typed data\n   */\n  public signTypedData: CustomSource[\"signTypedData\"] = async (parameters) => {\n    assert(parameters.domain, \"`domain` must be defined\");\n\n    const castedParameters = parameters as Eip712SignRequest[\"typed_data\"];\n    assert(castedParameters.domain.chainId, \"`domain.chainId` must be defined\");\n\n    const signature = await this.#signer.signEip712({\n      chain_id: Number(castedParameters.domain.chainId),\n      typed_data: castedParameters,\n    });\n\n    return ensureHex(signature);\n  };\n\n  /**\n   * It is recommended to use `prepareTransactionRequest` on your request\n   * before calling this function.\n   *\n   * Sign a transaction. This method will block if the key requires MFA approval.\n   * `type` and `chainId` must be defined. Only supports type \"legacy\" or \"eip1559\".\n   *\n   * @param transaction The transaction to sign\n   * @param options Contains an optional custom serializer\n   * @returns Signed transaction\n   * @throws {Error} if transaction.type isn't \"legacy\" or \"eip1559\", or if \"chainId\" isn't specified\n   */\n  public signTransaction: CustomSource[\"signTransaction\"] = async (transaction, options) => {\n    assert(\n      transaction.type === \"legacy\" || transaction.type === \"eip1559\",\n      `Unsupported transaction type '${transaction.type}', CubeSigner only supports type 'legacy' or 'eip1559'\")}'`,\n    );\n\n    assert(transaction.chainId, \"`chainId` must be defined\");\n\n    const formatted = formatTransactionRequest(transaction);\n    const rlpSignedTransaction = await this.#signer.signTransaction({\n      chain_id: transaction.chainId,\n      tx: formatted as EvmSignRequest[\"tx\"],\n    });\n\n    // CubeSigner returns an RLP-encoded transaction. Since Viem allows users to pass a custom serializer, we will\n    // now unserialize and reserialize with Viem's serializer.\n    const { r, s, v, yParity, ...parsedTransaction } = parseTransaction(\n      ensureHex(rlpSignedTransaction),\n    );\n    const serializer = options?.serializer ?? serializeTransaction;\n\n    return await serializer(parsedTransaction, { r, s, v, yParity } as Signature);\n  };\n}\n\n/**\n * @param input A hex string\n * @returns the input, type narrowed to Hex\n * @throws {Error} if input is not Hex\n */\nfunction ensureHex(input: string): Hex {\n  assert(isHex(input), `${input} is not hex`);\n  return input;\n}\n\n/**\n * @param value A value that is expected to be truthy\n * @param message The error message if the value is falsy\n * @throws {Error} if value is not truthy\n */\nfunction assert(value: unknown, message: string): asserts value {\n  if (!value) {\n    throw new Error(message);\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cubist-labs/cubesigner-sdk-viem",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cubist-labs/CubeSigner-TypeScript-SDK.git",
+    "directory": "packages/viem"
+  },
+  "version": "0.4.183-0",
+  "type": "module",
+  "description": "Viem CustomSource implementation",
+  "license": "MIT OR Apache-2.0",
+  "author": "Cubist, Inc.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "tsconfig.json",
+    "src/**",
+    "dist/**",
+    "../../NOTICE",
+    "../../LICENSE-APACHE",
+    "../../LICENSE-MIT"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepack": "tsc",
+    "test": "jest --maxWorkers=1"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "peerDependencies": {
+    "@cubist-labs/cubesigner-sdk": "^0.4.183-0",
+    "viem": "^2.38.2"
+  },
+  "devDependencies": {
+    "@cubist-labs/cubesigner-sdk-fs-storage": "^0.4.183-0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,158 @@
+import {
+  type Address,
+  type CustomSource,
+  type Hex,
+  type Signature,
+  bytesToHex,
+  formatTransactionRequest,
+  getAddress,
+  isHex,
+  parseTransaction,
+  serializeTransaction,
+  stringToHex,
+} from "viem";
+import {
+  type CubeSignerClient,
+  type Eip712SignRequest,
+  type EvmSignRequest,
+  EvmSigner,
+  type EvmSignerOptions,
+  type Key,
+} from "@cubist-labs/cubesigner-sdk";
+
+/**
+ * A class to wrap a CubeSigner key and client into a Viem {@link CustomSource}.
+ * Use Viem's `toAccount` to convert this to a Viem Account.
+ */
+export class CubeSignerSource implements CustomSource {
+  /** The internal CubeSigner signer used. */
+  readonly #signer: EvmSigner;
+
+  /** The address the wallet is associated with. */
+  public readonly address: Address;
+
+  /**
+   * Construct a Viem {@link CustomSource} around a CubeSigner key and client.
+   * Use Viem's `toAccount` to convert this to a Viem Account.
+   *
+   * @param address The EVM address this wallet is associated with
+   * @param client The session used for signing. Must have necessary scopes.
+   * @param options MFA options for the client to respect
+   * @throws {Error} if the address is not a valid EVM address
+   */
+  constructor(address: Key | string, client: CubeSignerClient, options?: EvmSignerOptions) {
+    this.#signer = new EvmSigner(address, client, options);
+
+    // NOTE: `getAddress` will checksum the address and throw if it's an invalid EVM address.
+    this.address = getAddress(this.#signer.address);
+
+    // Scope these functions to properly resolve `this`
+    this.signMessage = this.signMessage.bind(this);
+    this.signTransaction = this.signTransaction.bind(this);
+    this.signTypedData = this.signTypedData.bind(this);
+  }
+
+  /**
+   * Signs arbitrary messages. This uses CubeSigner's EIP-191 signing endpoint.
+   * The key (for this session) must have the `"AllowRawBlobSigning"` or
+   * `"AllowEip191Signing"` policy attached.
+   *
+   * @param root Object around the message
+   * @param root.message The message to sign
+   * @returns The signature
+   */
+  public signMessage: CustomSource["signMessage"] = async ({ message }) => {
+    let hex;
+    if (typeof message === "string") {
+      hex = stringToHex(message);
+    } else if (isHex(message.raw)) {
+      hex = message.raw;
+    } else {
+      hex = bytesToHex(message.raw);
+    }
+
+    const signature = await this.#signer.signEip191({ data: hex });
+
+    return ensureHex(signature);
+  };
+
+  /**
+   * Signs EIP-712 typed data. This uses CubeSigner's EIP-712 signing endpoint.
+   * The key (for this session) must have the `"AllowRawBlobSigning"` or
+   * `"AllowEip712Signing"` policy attached.
+   * `chainId` must be specified within the `domain`.
+   *
+   * @param parameters Typed data
+   * @returns signature for the typed data
+   */
+  public signTypedData: CustomSource["signTypedData"] = async (parameters) => {
+    assert(parameters.domain, "`domain` must be defined");
+
+    const castedParameters = parameters as Eip712SignRequest["typed_data"];
+    assert(castedParameters.domain.chainId, "`domain.chainId` must be defined");
+
+    const signature = await this.#signer.signEip712({
+      chain_id: Number(castedParameters.domain.chainId),
+      typed_data: castedParameters,
+    });
+
+    return ensureHex(signature);
+  };
+
+  /**
+   * It is recommended to use `prepareTransactionRequest` on your request
+   * before calling this function.
+   *
+   * Sign a transaction. This method will block if the key requires MFA approval.
+   * `type` and `chainId` must be defined. Only supports type "legacy" or "eip1559".
+   *
+   * @param transaction The transaction to sign
+   * @param options Contains an optional custom serializer
+   * @returns Signed transaction
+   * @throws {Error} if transaction.type isn't "legacy" or "eip1559", or if "chainId" isn't specified
+   */
+  public signTransaction: CustomSource["signTransaction"] = async (transaction, options) => {
+    assert(
+      transaction.type === "legacy" || transaction.type === "eip1559",
+      `Unsupported transaction type '${transaction.type}', CubeSigner only supports type 'legacy' or 'eip1559'")}'`,
+    );
+
+    assert(transaction.chainId, "`chainId` must be defined");
+
+    const formatted = formatTransactionRequest(transaction);
+    const rlpSignedTransaction = await this.#signer.signTransaction({
+      chain_id: transaction.chainId,
+      tx: formatted as EvmSignRequest["tx"],
+    });
+
+    // CubeSigner returns an RLP-encoded transaction. Since Viem allows users to pass a custom serializer, we will
+    // now unserialize and reserialize with Viem's serializer.
+    const { r, s, v, yParity, ...parsedTransaction } = parseTransaction(
+      ensureHex(rlpSignedTransaction),
+    );
+    const serializer = options?.serializer ?? serializeTransaction;
+
+    return await serializer(parsedTransaction, { r, s, v, yParity } as Signature);
+  };
+}
+
+/**
+ * @param input A hex string
+ * @returns the input, type narrowed to Hex
+ * @throws {Error} if input is not Hex
+ */
+function ensureHex(input: string): Hex {
+  assert(isHex(input), `${input} is not hex`);
+  return input;
+}
+
+/**
+ * @param value A value that is expected to be truthy
+ * @param message The error message if the value is falsy
+ * @throws {Error} if value is not truthy
+ */
+function assert(value: unknown, message: string): asserts value {
+  if (!value) {
+    throw new Error(message);
+  }
+}