kokio-sdk 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kokio-sdk",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "",
   "type": "module",
   "main": "./dist/esm/config.js",

package/src/logic/account-kit/createSmartAccount.ts

@@ -25,7 +25,7 @@ import { _getChainSpecificConstants, ZERO } from "../constants.js";
 import { _add0x, _concatUint8Arrays, _remove0x, _shouldRemoveLeadingZero } from "../utils.js";
 import { P256Key, WebAuthnSignature } from "../../types.js";
 import { DeviceWallet, DeviceWalletFactory } from "../../abis/index.js";
-import { _signMessageWithTurnkey, _signTypedDataWithTurnkey } from "../services/turnkeyClient.js";
+import { _signMessageWithTurnkey, _signTypedDataWithTurnkey, _stampAndSignMessageWithTurnkey, _stampAndSignTypedDataWithTurnkey } from "../services/turnkeyClient.js";
 import { alchemyGasManagerMiddleware } from "@account-kit/infra";
 
 const _encodeExecute = async (tx: AccountOp) => {
@@ -140,6 +140,7 @@ const getCounterFactualAddress = async (client: WalletClient, deviceUniqueIdenti
 	const values = _getChainSpecificConstants(chainID, rpcURL);
 	const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
 
+	
 	sender = sender? sender : values.factoryAddresses.SENDER_CREATOR;
 	const uniqueSaltBytes32 = prepareSaltForCreate2(sender, salt);
 	const initCodeHash = await getInitCodeHash(client, deviceUniqueIdentifier, deviceWalletOwnerKey);
@@ -207,7 +208,7 @@ const _encodeSignature = async (webAuthnSignature: WebAuthnSignature): Promise<H
 
 const _signMessage = async (message: SignableMessage, turnkeyClient: TurnkeyClient, organiationId: string, signWith: Address): Promise<Hex> => {
 
-	const webAuthnSignature = await _signMessageWithTurnkey(turnkeyClient, organiationId, signWith, message);
+	const webAuthnSignature = await _stampAndSignMessageWithTurnkey(turnkeyClient, organiationId, signWith, message);
 
 	return _encodeSignature(webAuthnSignature);
 }
@@ -217,7 +218,7 @@ const _signTypedData = async <
     primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
 > (typedData: TypedDataDefinition<typedData, primaryType>, turnkeyClient: TurnkeyClient, organiationId: string, signWith: Address): Promise<Hex> => {
 
-	const webAuthnSignature = await _signTypedDataWithTurnkey(turnkeyClient, organiationId, signWith, typedData);
+	const webAuthnSignature = await _stampAndSignTypedDataWithTurnkey(turnkeyClient, organiationId, signWith, typedData);
 
 	return _encodeSignature(webAuthnSignature);
 }

package/src/logic/services/turnkeyClient.ts

@@ -1,6 +1,6 @@
-import { assertActivityCompleted, assertNonNull, TurnkeyClient } from "@turnkey/http"
+import { assertActivityCompleted, assertNonNull, TurnkeyClient, TActivityResponse } from "@turnkey/http"
 import { Address, hashMessage, hashTypedData, SignableMessage, toHex, TypedData, TypedDataDefinition } from "viem";
-import { decodeAttestationObject, decodeClientDataJSON } from "@simplewebauthn/server/helpers";
+import { decodeAttestationObject, decodeClientDataJSON, parseAuthenticatorData } from "@simplewebauthn/server/helpers";
 import { base64UrlToBuffer } from "../utils.js";
 import { WebAuthnSignature } from "../../types.js";
 
@@ -78,3 +78,91 @@ export const _signTypedDataWithTurnkey = async <
         s: BigInt(signature.s) 
     }
 }
+
+export const _stampAndSignMessageWithTurnkey = async (client: TurnkeyClient, organizationId: string, signWith: Address, message: SignableMessage): Promise<WebAuthnSignature> => {
+    
+    const payload = hashMessage(message);
+    
+    const signedRequest = await client.stampSignRawPayload({
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+        organizationId: organizationId,
+        parameters: {
+            signWith: signWith,
+            payload: payload,
+            encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+            hashFunction: "HASH_FUNCTION_NO_OP",
+        },
+        timestampMs: String(Date.now()), // millisecond timestamp
+    });
+
+    if (!signedRequest) throw new Error('Error: Failed to get signed request')
+    
+    const stampedHeaderValue = JSON.parse(signedRequest.stamp.stampHeaderValue);
+
+    const response:TActivityResponse = await client.request('/public/v1/submit/sign_raw_payload', signedRequest)
+
+    if (!response || !response.activity) throw new Error('Error: Failed to sign payload');
+
+    const activity = response.activity;
+
+    assertActivityCompleted(activity);
+
+    const authenticatorData = base64UrlToBuffer(stampedHeaderValue.authenticatorData);
+    const decodedClientDataJson = decodeClientDataJSON(stampedHeaderValue.clientDataJson);
+
+    const signature = assertNonNull(activity.result.signRawPayloadResult);
+
+    return {
+        authenticatorData: toHex(authenticatorData),
+        clientDataJSON: JSON.stringify(decodedClientDataJson),
+        challengeIndex: BigInt(23),
+        typeIndex: BigInt(1),
+        r: BigInt(signature.r),
+        s: BigInt(signature.s) 
+    }
+} 
+
+export const _stampAndSignTypedDataWithTurnkey = async <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+> (client: TurnkeyClient, organizationId: string, signWith: Address, typedData: TypedDataDefinition<typedData, primaryType>): Promise<WebAuthnSignature> => {
+    
+    const payload = hashTypedData(typedData);
+    
+    const signedRequest = await client.stampSignRawPayload({
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+        organizationId: organizationId,
+        parameters: {
+            signWith: signWith,
+            payload: payload,
+            encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+            hashFunction: "HASH_FUNCTION_NO_OP",
+        },
+        timestampMs: String(Date.now()), // millisecond timestamp
+    });
+
+    if (!signedRequest) throw new Error('Error: Failed to get signed request')
+    
+    const stampedHeaderValue = JSON.parse(signedRequest.stamp.stampHeaderValue);
+
+    const response:TActivityResponse = await client.request('/public/v1/submit/sign_raw_payload', signedRequest)
+
+    if (!response || !response.activity) throw new Error('Error: Failed to sign payload');
+
+    const activity = response.activity;
+
+    assertActivityCompleted(activity);
+
+    const authenticatorData = base64UrlToBuffer(stampedHeaderValue.authenticatorData);
+    const decodedClientDataJson = decodeClientDataJSON(stampedHeaderValue.clientDataJson);
+    const signature = assertNonNull(activity.result.signRawPayloadResult);
+
+    return {
+        authenticatorData: toHex(authenticatorData),
+        clientDataJSON: JSON.stringify(decodedClientDataJson),
+        challengeIndex: BigInt(23),
+        typeIndex: BigInt(1),
+        r: BigInt(signature.r),
+        s: BigInt(signature.s) 
+    }
+}