@cubist-labs/cubesigner-sdk-viem 0.4.209 → 0.4.214

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export declare class CubeSignerSource implements CustomSource {
      * @returns signature for the typed data
      */
     signTypedData: CustomSource["signTypedData"];
+    signAuthorization: CustomSource["signAuthorization"];
     /**
      * It is recommended to use `prepareTransactionRequest` on your request
      * before calling this function.

package/dist/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EAYlB,MAAM,MAAM,CAAC;AACd,OAAO,EACL,KAAK,gBAAgB,EAIrB,KAAK,gBAAgB,EACrB,KAAK,GAAG,EAET,MAAM,6BAA6B,CAAC;AAGrC;;;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;IAavF;;;;;;;;OAQG;IACI,WAAW,EAAE,YAAY,CAAC,aAAa,CAAC,CAa7C;IAEF;;;;;;;;OAQG;IACI,aAAa,EAAE,YAAY,CAAC,eAAe,CAAC,CAYjD;IAEK,iBAAiB,EAAE,YAAY,CAAC,mBAAmB,CAAC,CAiBzD;IAEF;;;;;;;;;;;OAWG;IACI,eAAe,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAsBrD;CACH"}

package/dist/index.js

@@ -10,8 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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";
+import { bytesToHex, formatTransactionRequest, getAddress, isHex, parseSignature, parseTransaction, serializeTransaction, stringToHex, } from "viem";
+import { EvmSigner, encodeToBase64, } from "@cubist-labs/cubesigner-sdk";
+import { hashAuthorization, hexToBytes } from "viem/utils";
 /**
  * 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.
@@ -71,6 +72,22 @@ export class CubeSignerSource {
             });
             return ensureHex(signature);
         };
+        this.signAuthorization = async (parameters) => {
+            const hashToSign = hashAuthorization(parameters);
+            const key = await __classPrivateFieldGet(this, _CubeSignerSource_signer, "f").key();
+            // TODO(CS-3720): use the typed endpoint once we have it
+            const resp = await key.signBlob({
+                message_base64: encodeToBase64(hexToBytes(hashToSign)),
+            });
+            const data = await __classPrivateFieldGet(this, _CubeSignerSource_signer, "f").handleMfa(resp);
+            const signature = ensureHex(data.signature);
+            return {
+                address: parameters.contractAddress ?? parameters.address,
+                nonce: parameters.nonce,
+                chainId: parameters.chainId,
+                ...parseSignature(signature),
+            };
+        };
         /**
          * It is recommended to use `prepareTransactionRequest` on your request
          * before calling this function.
@@ -104,6 +121,7 @@ export class CubeSignerSource {
         this.signMessage = this.signMessage.bind(this);
         this.signTransaction = this.signTransaction.bind(this);
         this.signTypedData = this.signTypedData.bind(this);
+        this.signAuthorization = this.signAuthorization?.bind(this);
     }
 }
 _CubeSignerSource_signer = new WeakMap();
@@ -126,4 +144,4 @@ function assert(value, message) {
         throw new Error(message);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Address,\n  type CustomSource,\n  type Hex,\n  type SignAuthorizationReturnType,\n  type Signature,\n  bytesToHex,\n  formatTransactionRequest,\n  getAddress,\n  isHex,\n  parseSignature,\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  encodeToBase64,\n} from \"@cubist-labs/cubesigner-sdk\";\nimport { hashAuthorization, hexToBytes } from \"viem/utils\";\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    this.signAuthorization = this.signAuthorization?.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  public signAuthorization: CustomSource[\"signAuthorization\"] = async (\n    parameters,\n  ): Promise<SignAuthorizationReturnType> => {\n    const hashToSign = hashAuthorization(parameters);\n    const key = await this.#signer.key();\n    // TODO(CS-3720): use the typed endpoint once we have it\n    const resp = await key.signBlob({\n      message_base64: encodeToBase64(hexToBytes(hashToSign)),\n    });\n    const data = await this.#signer.handleMfa(resp);\n    const signature = ensureHex(data.signature);\n    return {\n      address: parameters.contractAddress ?? parameters.address,\n      nonce: parameters.nonce,\n      chainId: parameters.chainId,\n      ...parseSignature(signature),\n    };\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

@@ -5,7 +5,7 @@
     "url": "git+https://github.com/cubist-labs/CubeSigner-TypeScript-SDK.git",
     "directory": "packages/viem"
   },
-  "version": "0.4.209",
+  "version": "0.4.214",
   "type": "module",
   "description": "Viem CustomSource implementation",
   "license": "MIT OR Apache-2.0",
@@ -29,10 +29,10 @@
     "test": "test"
   },
   "peerDependencies": {
-    "@cubist-labs/cubesigner-sdk": "^0.4.209",
+    "@cubist-labs/cubesigner-sdk": "^0.4.214",
     "viem": "^2.38.2"
   },
   "devDependencies": {
-    "@cubist-labs/cubesigner-sdk-fs-storage": "^0.4.209"
+    "@cubist-labs/cubesigner-sdk-fs-storage": "^0.4.214"
   }
 }

package/src/index.ts

@@ -2,11 +2,13 @@ import {
   type Address,
   type CustomSource,
   type Hex,
+  type SignAuthorizationReturnType,
   type Signature,
   bytesToHex,
   formatTransactionRequest,
   getAddress,
   isHex,
+  parseSignature,
   parseTransaction,
   serializeTransaction,
   stringToHex,
@@ -18,7 +20,9 @@ import {
   EvmSigner,
   type EvmSignerOptions,
   type Key,
+  encodeToBase64,
 } from "@cubist-labs/cubesigner-sdk";
+import { hashAuthorization, hexToBytes } from "viem/utils";
 
 /**
  * A class to wrap a CubeSigner key and client into a Viem {@link CustomSource}.
@@ -50,6 +54,7 @@ export class CubeSignerSource implements CustomSource {
     this.signMessage = this.signMessage.bind(this);
     this.signTransaction = this.signTransaction.bind(this);
     this.signTypedData = this.signTypedData.bind(this);
+    this.signAuthorization = this.signAuthorization?.bind(this);
   }
 
   /**
@@ -99,6 +104,25 @@ export class CubeSignerSource implements CustomSource {
     return ensureHex(signature);
   };
 
+  public signAuthorization: CustomSource["signAuthorization"] = async (
+    parameters,
+  ): Promise<SignAuthorizationReturnType> => {
+    const hashToSign = hashAuthorization(parameters);
+    const key = await this.#signer.key();
+    // TODO(CS-3720): use the typed endpoint once we have it
+    const resp = await key.signBlob({
+      message_base64: encodeToBase64(hexToBytes(hashToSign)),
+    });
+    const data = await this.#signer.handleMfa(resp);
+    const signature = ensureHex(data.signature);
+    return {
+      address: parameters.contractAddress ?? parameters.address,
+      nonce: parameters.nonce,
+      chainId: parameters.chainId,
+      ...parseSignature(signature),
+    };
+  };
+
   /**
    * It is recommended to use `prepareTransactionRequest` on your request
    * before calling this function.