@dynamic-labs-wallet/svm 1.1.40 → 1.1.41

package/index.cjs

@@ -423,4 +423,173 @@ class DynamicSvmWalletClient extends browser.DynamicWalletClient {
     }
 }
 
+const ADVANCE_NONCE_ACCOUNT_INSTRUCTION = 4;
+const isHexBytes = (value)=>/^(?:[0-9a-fA-F]{2})+$/.test(value);
+const assertNetworkChainId = (chainId)=>{
+    if (!(chainId == null ? void 0 : chainId.trim()) || chainId.trim() !== chainId) {
+        throw new Error('SVM signing intent requires a network chainId');
+    }
+    return chainId;
+};
+const parseUnsignedMessage = (transaction)=>{
+    if (!isHexBytes(transaction)) {
+        throw new Error('SVM signing intent requires a hex serialized message');
+    }
+    const message = web3_js.VersionedMessage.deserialize(Uint8Array.from(Buffer.from(transaction, 'hex')));
+    // Compare as hex: the browser Buffer polyfill's equals() rejects a plain Uint8Array.
+    if (Buffer.from(message.serialize()).toString('hex') !== transaction.toLowerCase()) {
+        throw new Error('SVM signing intent requires one complete unsigned message');
+    }
+    return message;
+};
+const assertSupportedMessageShape = (message)=>{
+    if (message.version !== 'legacy' && message.version !== 0) {
+        throw new Error('Unsupported SVM message version');
+    }
+    if (message.addressTableLookups.length !== 0) {
+        throw new Error('SVM signing intent does not support address-table lookups');
+    }
+};
+const resolveFeePayer = (message, accountAddress)=>{
+    var _message_staticAccountKeys_;
+    const feePayer = (_message_staticAccountKeys_ = message.staticAccountKeys[0]) == null ? void 0 : _message_staticAccountKeys_.toBase58();
+    if (!feePayer || feePayer !== accountAddress || message.header.numRequiredSignatures < 1) {
+        throw new Error('SVM fee payer must be the signing account');
+    }
+    return feePayer;
+};
+const isAdvanceNonceInstruction = (message, instruction)=>{
+    const program = message.staticAccountKeys[instruction.programIdIndex];
+    const data = Buffer.from(instruction.data);
+    return Boolean(program == null ? void 0 : program.equals(web3_js.SystemProgram.programId)) && data.length >= 4 && data.readUInt32LE(0) === ADVANCE_NONCE_ACCOUNT_INSTRUCTION;
+};
+const assertNoDurableNonce = (message)=>{
+    if (message.compiledInstructions.some((instruction)=>isAdvanceNonceInstruction(message, instruction))) {
+        throw new Error('SVM signing intent does not support durable nonce transactions');
+    }
+};
+const messageVersionOf = (message)=>{
+    if (message.version === 'legacy') return 'legacy';
+    return 'v0';
+};
+const toTransactionOperation = (message, chainId, feePayer)=>({
+        kind: 'transaction',
+        chainName: 'SVM',
+        chainId,
+        messageVersion: messageVersionOf(message),
+        feePayer,
+        header: {
+            numRequiredSignatures: message.header.numRequiredSignatures,
+            numReadonlySignedAccounts: message.header.numReadonlySignedAccounts,
+            numReadonlyUnsignedAccounts: message.header.numReadonlyUnsignedAccounts
+        },
+        staticAccountKeys: message.staticAccountKeys.map((key)=>key.toBase58()),
+        instructions: message.compiledInstructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: `0x${Buffer.from(instruction.data).toString('hex')}`
+            }))
+    });
+const prepareSvmTransactionSigningOperation = ({ transaction, accountAddress, chainId })=>{
+    const networkChainId = assertNetworkChainId(chainId);
+    const message = parseUnsignedMessage(transaction);
+    assertSupportedMessageShape(message);
+    const feePayer = resolveFeePayer(message, accountAddress);
+    assertNoDurableNonce(message);
+    return {
+        operation: toTransactionOperation(message, networkChainId, feePayer),
+        lifetime: {
+            refreshable: 'blockhash'
+        }
+    };
+};
+const BLOCKHASH_BYTES = 32;
+const signedSvmOperation = (intent)=>{
+    var _intent_lifetime;
+    const { operation } = intent;
+    if (operation.kind !== 'transaction' || operation.chainName !== 'SVM' || ((_intent_lifetime = intent.lifetime) == null ? void 0 : _intent_lifetime.refreshable) !== 'blockhash') {
+        throw new Error('Stored signing intent is not an SVM transaction');
+    }
+    return operation;
+};
+const assertBlockhash = (blockhash)=>{
+    if (!blockhash || new web3_js.PublicKey(blockhash).toBytes().length !== BLOCKHASH_BYTES) {
+        throw new Error('SVM transaction intent requires a blockhash');
+    }
+    return blockhash;
+};
+const instructionData = (data)=>Uint8Array.from(Buffer.from(data.slice(2), 'hex'));
+const buildLegacyMessage = (operation, recentBlockhash)=>new web3_js.Message({
+        header: operation.header,
+        accountKeys: operation.staticAccountKeys.map((key)=>new web3_js.PublicKey(key)),
+        recentBlockhash,
+        instructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accounts: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: bs58.encode(instructionData(instruction.data))
+            }))
+    });
+const buildV0Message = (operation, recentBlockhash)=>new web3_js.MessageV0({
+        header: operation.header,
+        staticAccountKeys: operation.staticAccountKeys.map((key)=>new web3_js.PublicKey(key)),
+        recentBlockhash,
+        compiledInstructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: instructionData(instruction.data)
+            })),
+        addressTableLookups: []
+    });
+const buildMessage = (operation, recentBlockhash)=>{
+    if (operation.messageVersion === 'legacy') return buildLegacyMessage(operation, recentBlockhash);
+    return buildV0Message(operation, recentBlockhash);
+};
+/** Orders the signed operation's fields as `prepareSvmTransactionSigningOperation` does, for comparison. */ const canonicalSvmOperation = (operation)=>({
+        kind: operation.kind,
+        chainName: operation.chainName,
+        chainId: operation.chainId,
+        messageVersion: operation.messageVersion,
+        feePayer: operation.feePayer,
+        header: {
+            numRequiredSignatures: operation.header.numRequiredSignatures,
+            numReadonlySignedAccounts: operation.header.numReadonlySignedAccounts,
+            numReadonlyUnsignedAccounts: operation.header.numReadonlyUnsignedAccounts
+        },
+        staticAccountKeys: operation.staticAccountKeys,
+        instructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: instruction.accountKeyIndexes,
+                data: instruction.data.toLowerCase()
+            }))
+    });
+const assertRebuiltMatchesOperation = (transaction, accountAddress, operation)=>{
+    const rebuilt = prepareSvmTransactionSigningOperation({
+        transaction,
+        accountAddress,
+        chainId: operation.chainId
+    }).operation;
+    if (JSON.stringify(rebuilt) !== JSON.stringify(canonicalSvmOperation(operation))) {
+        throw new Error('Stored SVM transaction intent is malformed');
+    }
+};
+/**
+ * Reconstructs the unsigned serialized message (hex) from an approved intent.
+ * The signed intent carries no blockhash, so the caller supplies one. Passing the
+ * blockhash of the original message is fine while it is still valid.
+ */ const resumeSvmTransactionSigningIntent = ({ intent, lifetimeValue })=>{
+    const operation = signedSvmOperation(intent);
+    const recentBlockhash = assertBlockhash(lifetimeValue);
+    const transaction = Buffer.from(buildMessage(operation, recentBlockhash).serialize()).toString('hex');
+    assertRebuiltMatchesOperation(transaction, intent.accountAddress, operation);
+    return transaction;
+};
+
 exports.DynamicSvmWalletClient = DynamicSvmWalletClient;
+exports.prepareSvmTransactionSigningOperation = prepareSvmTransactionSigningOperation;
+exports.resumeSvmTransactionSigningIntent = resumeSvmTransactionSigningIntent;

package/index.esm.js

@@ -1,5 +1,5 @@
 import { DynamicWalletClient, getMPCChainConfig, ERROR_KEYGEN_FAILED, ERROR_PASSWORD_MISMATCH, ERROR_MULTIPLE_WALLETS_PER_CHAIN, ERROR_CREATE_WALLET_ACCOUNT, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_SIGN_MESSAGE, getEd25519PublicKeyFromRawScalar, ERROR_IMPORT_PRIVATE_KEY } from '@dynamic-labs-wallet/browser';
-import { VersionedMessage, VersionedTransaction, Keypair } from '@solana/web3.js';
+import { VersionedMessage, VersionedTransaction, Keypair, PublicKey, SystemProgram, Message, MessageV0 } from '@solana/web3.js';
 import bs58 from 'bs58';
 
 function _extends() {
@@ -421,4 +421,171 @@ class DynamicSvmWalletClient extends DynamicWalletClient {
     }
 }
 
-export { DynamicSvmWalletClient };
+const ADVANCE_NONCE_ACCOUNT_INSTRUCTION = 4;
+const isHexBytes = (value)=>/^(?:[0-9a-fA-F]{2})+$/.test(value);
+const assertNetworkChainId = (chainId)=>{
+    if (!(chainId == null ? void 0 : chainId.trim()) || chainId.trim() !== chainId) {
+        throw new Error('SVM signing intent requires a network chainId');
+    }
+    return chainId;
+};
+const parseUnsignedMessage = (transaction)=>{
+    if (!isHexBytes(transaction)) {
+        throw new Error('SVM signing intent requires a hex serialized message');
+    }
+    const message = VersionedMessage.deserialize(Uint8Array.from(Buffer.from(transaction, 'hex')));
+    // Compare as hex: the browser Buffer polyfill's equals() rejects a plain Uint8Array.
+    if (Buffer.from(message.serialize()).toString('hex') !== transaction.toLowerCase()) {
+        throw new Error('SVM signing intent requires one complete unsigned message');
+    }
+    return message;
+};
+const assertSupportedMessageShape = (message)=>{
+    if (message.version !== 'legacy' && message.version !== 0) {
+        throw new Error('Unsupported SVM message version');
+    }
+    if (message.addressTableLookups.length !== 0) {
+        throw new Error('SVM signing intent does not support address-table lookups');
+    }
+};
+const resolveFeePayer = (message, accountAddress)=>{
+    var _message_staticAccountKeys_;
+    const feePayer = (_message_staticAccountKeys_ = message.staticAccountKeys[0]) == null ? void 0 : _message_staticAccountKeys_.toBase58();
+    if (!feePayer || feePayer !== accountAddress || message.header.numRequiredSignatures < 1) {
+        throw new Error('SVM fee payer must be the signing account');
+    }
+    return feePayer;
+};
+const isAdvanceNonceInstruction = (message, instruction)=>{
+    const program = message.staticAccountKeys[instruction.programIdIndex];
+    const data = Buffer.from(instruction.data);
+    return Boolean(program == null ? void 0 : program.equals(SystemProgram.programId)) && data.length >= 4 && data.readUInt32LE(0) === ADVANCE_NONCE_ACCOUNT_INSTRUCTION;
+};
+const assertNoDurableNonce = (message)=>{
+    if (message.compiledInstructions.some((instruction)=>isAdvanceNonceInstruction(message, instruction))) {
+        throw new Error('SVM signing intent does not support durable nonce transactions');
+    }
+};
+const messageVersionOf = (message)=>{
+    if (message.version === 'legacy') return 'legacy';
+    return 'v0';
+};
+const toTransactionOperation = (message, chainId, feePayer)=>({
+        kind: 'transaction',
+        chainName: 'SVM',
+        chainId,
+        messageVersion: messageVersionOf(message),
+        feePayer,
+        header: {
+            numRequiredSignatures: message.header.numRequiredSignatures,
+            numReadonlySignedAccounts: message.header.numReadonlySignedAccounts,
+            numReadonlyUnsignedAccounts: message.header.numReadonlyUnsignedAccounts
+        },
+        staticAccountKeys: message.staticAccountKeys.map((key)=>key.toBase58()),
+        instructions: message.compiledInstructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: `0x${Buffer.from(instruction.data).toString('hex')}`
+            }))
+    });
+const prepareSvmTransactionSigningOperation = ({ transaction, accountAddress, chainId })=>{
+    const networkChainId = assertNetworkChainId(chainId);
+    const message = parseUnsignedMessage(transaction);
+    assertSupportedMessageShape(message);
+    const feePayer = resolveFeePayer(message, accountAddress);
+    assertNoDurableNonce(message);
+    return {
+        operation: toTransactionOperation(message, networkChainId, feePayer),
+        lifetime: {
+            refreshable: 'blockhash'
+        }
+    };
+};
+const BLOCKHASH_BYTES = 32;
+const signedSvmOperation = (intent)=>{
+    var _intent_lifetime;
+    const { operation } = intent;
+    if (operation.kind !== 'transaction' || operation.chainName !== 'SVM' || ((_intent_lifetime = intent.lifetime) == null ? void 0 : _intent_lifetime.refreshable) !== 'blockhash') {
+        throw new Error('Stored signing intent is not an SVM transaction');
+    }
+    return operation;
+};
+const assertBlockhash = (blockhash)=>{
+    if (!blockhash || new PublicKey(blockhash).toBytes().length !== BLOCKHASH_BYTES) {
+        throw new Error('SVM transaction intent requires a blockhash');
+    }
+    return blockhash;
+};
+const instructionData = (data)=>Uint8Array.from(Buffer.from(data.slice(2), 'hex'));
+const buildLegacyMessage = (operation, recentBlockhash)=>new Message({
+        header: operation.header,
+        accountKeys: operation.staticAccountKeys.map((key)=>new PublicKey(key)),
+        recentBlockhash,
+        instructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accounts: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: bs58.encode(instructionData(instruction.data))
+            }))
+    });
+const buildV0Message = (operation, recentBlockhash)=>new MessageV0({
+        header: operation.header,
+        staticAccountKeys: operation.staticAccountKeys.map((key)=>new PublicKey(key)),
+        recentBlockhash,
+        compiledInstructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: [
+                    ...instruction.accountKeyIndexes
+                ],
+                data: instructionData(instruction.data)
+            })),
+        addressTableLookups: []
+    });
+const buildMessage = (operation, recentBlockhash)=>{
+    if (operation.messageVersion === 'legacy') return buildLegacyMessage(operation, recentBlockhash);
+    return buildV0Message(operation, recentBlockhash);
+};
+/** Orders the signed operation's fields as `prepareSvmTransactionSigningOperation` does, for comparison. */ const canonicalSvmOperation = (operation)=>({
+        kind: operation.kind,
+        chainName: operation.chainName,
+        chainId: operation.chainId,
+        messageVersion: operation.messageVersion,
+        feePayer: operation.feePayer,
+        header: {
+            numRequiredSignatures: operation.header.numRequiredSignatures,
+            numReadonlySignedAccounts: operation.header.numReadonlySignedAccounts,
+            numReadonlyUnsignedAccounts: operation.header.numReadonlyUnsignedAccounts
+        },
+        staticAccountKeys: operation.staticAccountKeys,
+        instructions: operation.instructions.map((instruction)=>({
+                programIdIndex: instruction.programIdIndex,
+                accountKeyIndexes: instruction.accountKeyIndexes,
+                data: instruction.data.toLowerCase()
+            }))
+    });
+const assertRebuiltMatchesOperation = (transaction, accountAddress, operation)=>{
+    const rebuilt = prepareSvmTransactionSigningOperation({
+        transaction,
+        accountAddress,
+        chainId: operation.chainId
+    }).operation;
+    if (JSON.stringify(rebuilt) !== JSON.stringify(canonicalSvmOperation(operation))) {
+        throw new Error('Stored SVM transaction intent is malformed');
+    }
+};
+/**
+ * Reconstructs the unsigned serialized message (hex) from an approved intent.
+ * The signed intent carries no blockhash, so the caller supplies one. Passing the
+ * blockhash of the original message is fine while it is still valid.
+ */ const resumeSvmTransactionSigningIntent = ({ intent, lifetimeValue })=>{
+    const operation = signedSvmOperation(intent);
+    const recentBlockhash = assertBlockhash(lifetimeValue);
+    const transaction = Buffer.from(buildMessage(operation, recentBlockhash).serialize()).toString('hex');
+    assertRebuiltMatchesOperation(transaction, intent.accountAddress, operation);
+    return transaction;
+};
+
+export { DynamicSvmWalletClient, prepareSvmTransactionSigningOperation, resumeSvmTransactionSigningIntent };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@dynamic-labs-wallet/svm",
-  "version": "1.1.40",
+  "version": "1.1.41",
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@dynamic-labs-wallet/browser": "1.1.40",
+    "@dynamic-labs-wallet/browser": "1.1.41",
+    "@dynamic-labs-wallet/core": "1.1.41",
     "@solana/web3.js": "^1.98.2",
     "bs58": "^6.0.0",
     "@dynamic-labs/sdk-api-core": "0.50.0"

package/src/svm/index.d.ts

@@ -1,2 +1,3 @@
 export * from './client.js';
+export { prepareSvmTransactionSigningOperation, resumeSvmTransactionSigningIntent } from './signingIntent.js';
 //# sourceMappingURL=index.d.ts.map

package/src/svm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svm/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svm/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,qCAAqC,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC"}

package/src/svm/signingIntent.d.ts

@@ -0,0 +1,16 @@
+import type { PreparedSvmTransactionSigningIntent, SigningIntent } from '@dynamic-labs-wallet/core';
+export declare const prepareSvmTransactionSigningOperation: ({ transaction, accountAddress, chainId, }: {
+    transaction: string;
+    accountAddress: string;
+    chainId: string | undefined;
+}) => PreparedSvmTransactionSigningIntent;
+/**
+ * Reconstructs the unsigned serialized message (hex) from an approved intent.
+ * The signed intent carries no blockhash, so the caller supplies one. Passing the
+ * blockhash of the original message is fine while it is still valid.
+ */
+export declare const resumeSvmTransactionSigningIntent: ({ intent, lifetimeValue, }: {
+    intent: SigningIntent;
+    lifetimeValue: string | undefined;
+}) => string;
+//# sourceMappingURL=signingIntent.d.ts.map

package/src/svm/signingIntent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signingIntent.d.ts","sourceRoot":"","sources":["../../src/svm/signingIntent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mCAAmC,EACnC,aAAa,EAEd,MAAM,2BAA2B,CAAC;AA2FnC,eAAO,MAAM,qCAAqC,8CAI/C;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,KAAG,mCAWH,CAAC;AA0FF;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,+BAG3C;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC,KAAG,MAMH,CAAC"}