@dynamic-labs-wallet/sui 0.0.0-beta.146.1

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,221 @@
+'use strict';
+
+var browser = require('@dynamic-labs-wallet/browser');
+var ed25519 = require('@mysten/sui/keypairs/ed25519');
+var cryptography = require('@mysten/sui/cryptography');
+var verify = require('@mysten/sui/verify');
+var bcs = require('@mysten/sui/bcs');
+var blake2b = require('@noble/hashes/blake2b');
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const ERROR_KEYGEN_FAILED = 'Error with keygen';
+const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating sui wallet account';
+const ERROR_VERIFY_MESSAGE_SIGNATURE = 'Error verifying message signature';
+const ERROR_VERIFY_TRANSACTION_SIGNATURE = 'Error verifying transaction signature';
+
+const formatMessage = (message, intentScope)=>{
+    if (intentScope === 'TransactionData') {
+        const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
+        const intentMessage = cryptography.messageWithIntent(intentScope, txBytes);
+        return blake2b.blake2b(intentMessage, {
+            dkLen: 32
+        });
+    } else {
+        const encodedMessage = new TextEncoder().encode(message);
+        const serializedMessage = bcs.bcs.vector(bcs.bcs.u8()).serialize(encodedMessage).toBytes();
+        const intentMessage = cryptography.messageWithIntent(intentScope, serializedMessage);
+        return blake2b.blake2b(intentMessage, {
+            dkLen: 32
+        });
+    }
+};
+
+class DynamicSuiWalletClient extends browser.DynamicWalletClient {
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        try {
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress: accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: browser.getClientKeyShareBackupInfo()
+                    });
+                }
+            });
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            const { accountAddress, publicKeyHex } = this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
+            // TODO: remove this once iframe handling for secret shares is implemented
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            // Backup the new wallet without waiting for the promise to resolve
+            void this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async getRawPublicKeyFromClientKeyShares({ chainName, clientKeyShare }) {
+        const chainConfig = browser.getMPCChainConfig(chainName);
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        const rawPublicKey = await this.derivePublicKey({
+            chainName,
+            keyShare: clientKeyShare,
+            derivationPath
+        });
+        return rawPublicKey;
+    }
+    /**
+   * Format Ed25519 signature to string that satisfies Sui signature standard
+   */ async formatSignature(signatureEd25519, accountAddress) {
+        // get public key from keyshare
+        // TODO: handle this more gracefully from the client key shares if possible
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
+            chainName: this.chainName,
+            clientKeyShare: clientKeyShares[0]
+        });
+        const suiPublicKey = new ed25519.Ed25519PublicKey(rawPublicKey);
+        const serializedSignature = cryptography.toSerializedSignature({
+            signature: signatureEd25519,
+            signatureScheme: 'ED25519',
+            publicKey: suiPublicKey
+        });
+        return serializedSignature;
+    }
+    async verifyMessageSignature({ message, signature, accountAddress }) {
+        try {
+            const messageBytes = new TextEncoder().encode(message);
+            const verifiedPublicKey = await verify.verifyPersonalMessageSignature(messageBytes, signature);
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === accountAddress.toLowerCase();
+            if (!isVerified) {
+                throw new Error(ERROR_VERIFY_MESSAGE_SIGNATURE);
+            }
+        } catch (error) {
+            this.logger.error('Error verifying signature:', error);
+            throw error;
+        }
+    }
+    async verifyTransactionSignature({ transaction, signature, senderAddress }) {
+        try {
+            const txBytes = Uint8Array.from(Buffer.from(transaction, 'hex'));
+            const verifiedPublicKey = await verify.verifyTransactionSignature(txBytes, signature);
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === senderAddress.toLowerCase();
+            if (!isVerified) {
+                throw new Error(ERROR_VERIFY_TRANSACTION_SIGNATURE);
+            }
+        } catch (error) {
+            this.logger.error('Error verifying signature:', error);
+            throw error;
+        }
+    }
+    async signMessage({ message, accountAddress, password = undefined }) {
+        if (!accountAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const formattedMessage = formatMessage(message, 'PersonalMessage');
+            const signatureEd25519 = await this.sign({
+                message: formattedMessage,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password
+            });
+            const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
+            await this.verifyMessageSignature({
+                message,
+                signature: formattedSignature,
+                accountAddress
+            });
+            return formattedSignature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    async signTransaction({ transaction, senderAddress, password = undefined }) {
+        if (!senderAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const formattedMessage = formatMessage(transaction, 'TransactionData');
+            const signatureEd25519 = await this.sign({
+                message: formattedMessage,
+                accountAddress: senderAddress,
+                chainName: this.chainName,
+                password
+            });
+            const formattedSignature = await this.formatSignature(signatureEd25519, senderAddress);
+            await this.verifyTransactionSignature({
+                transaction,
+                signature: formattedSignature,
+                senderAddress
+            });
+            return formattedSignature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    deriveAccountAddress({ rawPublicKey }) {
+        const publicKey = new ed25519.Ed25519PublicKey(rawPublicKey);
+        const accountAddress = publicKey.toSuiAddress();
+        return {
+            accountAddress,
+            publicKeyHex: Buffer.from(rawPublicKey).toString('hex')
+        };
+    }
+    async getSuiWallets() {
+        const wallets = await this.getWallets();
+        const suiWallets = wallets.filter((wallet)=>wallet.chainName === 'sui');
+        return suiWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug
+        }), this.chainName = 'SUI';
+    }
+}
+
+exports.DynamicSuiWalletClient = DynamicSuiWalletClient;

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -0,0 +1,219 @@
+import { DynamicWalletClient, getClientKeyShareBackupInfo, getMPCChainConfig } from '@dynamic-labs-wallet/browser';
+import { Ed25519PublicKey } from '@mysten/sui/keypairs/ed25519';
+import { messageWithIntent, toSerializedSignature } from '@mysten/sui/cryptography';
+import { verifyPersonalMessageSignature, verifyTransactionSignature } from '@mysten/sui/verify';
+import { bcs } from '@mysten/sui/bcs';
+import { blake2b } from '@noble/hashes/blake2b';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const ERROR_KEYGEN_FAILED = 'Error with keygen';
+const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating sui wallet account';
+const ERROR_VERIFY_MESSAGE_SIGNATURE = 'Error verifying message signature';
+const ERROR_VERIFY_TRANSACTION_SIGNATURE = 'Error verifying transaction signature';
+
+const formatMessage = (message, intentScope)=>{
+    if (intentScope === 'TransactionData') {
+        const txBytes = Uint8Array.from(Buffer.from(message, 'hex'));
+        const intentMessage = messageWithIntent(intentScope, txBytes);
+        return blake2b(intentMessage, {
+            dkLen: 32
+        });
+    } else {
+        const encodedMessage = new TextEncoder().encode(message);
+        const serializedMessage = bcs.vector(bcs.u8()).serialize(encodedMessage).toBytes();
+        const intentMessage = messageWithIntent(intentScope, serializedMessage);
+        return blake2b(intentMessage, {
+            dkLen: 32
+        });
+    }
+};
+
+class DynamicSuiWalletClient extends DynamicWalletClient {
+    async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError }) {
+        try {
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, clientKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // update wallet map
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                        accountAddress: accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+                    });
+                }
+            });
+            if (!rawPublicKey || !clientKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            const { accountAddress, publicKeyHex } = this.deriveAccountAddress({
+                rawPublicKey: rawPublicKey
+            });
+            // Update client key shares in wallet map
+            // warning: this might result in race condition if `onCeremonyComplete` executes at the same time
+            // TODO: remove this once iframe handling for secret shares is implemented
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares,
+                overwriteOrMerge: 'overwrite'
+            });
+            // Backup the new wallet without waiting for the promise to resolve
+            void this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                clientKeyShares,
+                password
+            });
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex
+            };
+        } catch (error) {
+            this.logger.error(ERROR_CREATE_WALLET_ACCOUNT, error);
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    async getRawPublicKeyFromClientKeyShares({ chainName, clientKeyShare }) {
+        const chainConfig = getMPCChainConfig(chainName);
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        const rawPublicKey = await this.derivePublicKey({
+            chainName,
+            keyShare: clientKeyShare,
+            derivationPath
+        });
+        return rawPublicKey;
+    }
+    /**
+   * Format Ed25519 signature to string that satisfies Sui signature standard
+   */ async formatSignature(signatureEd25519, accountAddress) {
+        // get public key from keyshare
+        // TODO: handle this more gracefully from the client key shares if possible
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        const rawPublicKey = await this.getRawPublicKeyFromClientKeyShares({
+            chainName: this.chainName,
+            clientKeyShare: clientKeyShares[0]
+        });
+        const suiPublicKey = new Ed25519PublicKey(rawPublicKey);
+        const serializedSignature = toSerializedSignature({
+            signature: signatureEd25519,
+            signatureScheme: 'ED25519',
+            publicKey: suiPublicKey
+        });
+        return serializedSignature;
+    }
+    async verifyMessageSignature({ message, signature, accountAddress }) {
+        try {
+            const messageBytes = new TextEncoder().encode(message);
+            const verifiedPublicKey = await verifyPersonalMessageSignature(messageBytes, signature);
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === accountAddress.toLowerCase();
+            if (!isVerified) {
+                throw new Error(ERROR_VERIFY_MESSAGE_SIGNATURE);
+            }
+        } catch (error) {
+            this.logger.error('Error verifying signature:', error);
+            throw error;
+        }
+    }
+    async verifyTransactionSignature({ transaction, signature, senderAddress }) {
+        try {
+            const txBytes = Uint8Array.from(Buffer.from(transaction, 'hex'));
+            const verifiedPublicKey = await verifyTransactionSignature(txBytes, signature);
+            const isVerified = verifiedPublicKey.toSuiAddress().toLowerCase() === senderAddress.toLowerCase();
+            if (!isVerified) {
+                throw new Error(ERROR_VERIFY_TRANSACTION_SIGNATURE);
+            }
+        } catch (error) {
+            this.logger.error('Error verifying signature:', error);
+            throw error;
+        }
+    }
+    async signMessage({ message, accountAddress, password = undefined }) {
+        if (!accountAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const formattedMessage = formatMessage(message, 'PersonalMessage');
+            const signatureEd25519 = await this.sign({
+                message: formattedMessage,
+                accountAddress: accountAddress,
+                chainName: this.chainName,
+                password
+            });
+            const formattedSignature = await this.formatSignature(signatureEd25519, accountAddress);
+            await this.verifyMessageSignature({
+                message,
+                signature: formattedSignature,
+                accountAddress
+            });
+            return formattedSignature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    async signTransaction({ transaction, senderAddress, password = undefined }) {
+        if (!senderAddress) {
+            throw new Error('Account address is required');
+        }
+        try {
+            const formattedMessage = formatMessage(transaction, 'TransactionData');
+            const signatureEd25519 = await this.sign({
+                message: formattedMessage,
+                accountAddress: senderAddress,
+                chainName: this.chainName,
+                password
+            });
+            const formattedSignature = await this.formatSignature(signatureEd25519, senderAddress);
+            await this.verifyTransactionSignature({
+                transaction,
+                signature: formattedSignature,
+                senderAddress
+            });
+            return formattedSignature;
+        } catch (error) {
+            this.logger.error('Error signing message:', error);
+            throw error;
+        }
+    }
+    deriveAccountAddress({ rawPublicKey }) {
+        const publicKey = new Ed25519PublicKey(rawPublicKey);
+        const accountAddress = publicKey.toSuiAddress();
+        return {
+            accountAddress,
+            publicKeyHex: Buffer.from(rawPublicKey).toString('hex')
+        };
+    }
+    async getSuiWallets() {
+        const wallets = await this.getWallets();
+        const suiWallets = wallets.filter((wallet)=>wallet.chainName === 'sui');
+        return suiWallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        super({
+            environmentId,
+            authToken,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            storageKey,
+            debug
+        }), this.chainName = 'SUI';
+    }
+}
+
+export { DynamicSuiWalletClient };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@dynamic-labs-wallet/sui",
+  "version": "0.0.0-beta.146.1",
+  "license": "MIT",
+  "dependencies": {
+    "@dynamic-labs-wallet/browser": "0.0.0-beta.146.1",
+    "@mysten/sui": "1.26.0",
+    "@noble/hashes": "1.7.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/sui/src",
+    "projectType": "library",
+    "name": "sui",
+    "targets": {
+      "build": {}
+    }
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs.js",
+      "default": "./index.cjs.js"
+    }
+  }
+}

package/src/client/client.d.ts

@@ -0,0 +1,42 @@
+import { ClientKeyShare, DynamicWalletClient, EcdsaPublicKey, ThresholdSignatureScheme, DynamicWalletClientProps } from '@dynamic-labs-wallet/browser';
+export declare class DynamicSuiWalletClient extends DynamicWalletClient {
+    readonly chainName = "SUI";
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, }: DynamicWalletClientProps);
+    createWalletAccount({ thresholdSignatureScheme, password, onError, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | undefined;
+    }>;
+    getRawPublicKeyFromClientKeyShares({ chainName, clientKeyShare, }: {
+        chainName: string;
+        clientKeyShare: ClientKeyShare;
+    }): Promise<any>;
+    /**
+     * Format Ed25519 signature to string that satisfies Sui signature standard
+     */
+    private formatSignature;
+    private verifyMessageSignature;
+    private verifyTransactionSignature;
+    signMessage({ message, accountAddress, password, }: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+    }): Promise<string>;
+    signTransaction({ transaction, senderAddress, password, }: {
+        transaction: string;
+        senderAddress: string;
+        password?: string;
+    }): Promise<string>;
+    deriveAccountAddress({ rawPublicKey }: {
+        rawPublicKey: Uint8Array;
+    }): {
+        accountAddress: string;
+        publicKeyHex: string;
+    };
+    getSuiWallets(): Promise<any>;
+}
+//# sourceMappingURL=client.d.ts.map

package/src/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EAGzB,MAAM,8BAA8B,CAAC;AAetC,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC7D,QAAQ,CAAC,SAAS,SAAS;gBAEf,EACV,aAAa,EACb,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,UAAU,EACV,KAAK,GACN,EAAE,wBAAwB;IAWrB,mBAAmB,CAAC,EACxB,wBAAwB,EACxB,QAAoB,EACpB,OAAO,GACR,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAC;QACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;KAClC,GAAG,OAAO,CAAC;QACV,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,cAAc,GAAG,UAAU,GAAG,SAAS,CAAC;KACvD,CAAC;IAuDI,kCAAkC,CAAC,EACvC,SAAS,EACT,cAAc,GACf,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,cAAc,CAAC;KAChC;IAYD;;OAEG;YACW,eAAe;YAyBf,sBAAsB;YA6BtB,0BAA0B;IA6BlC,WAAW,CAAC,EAChB,OAAO,EACP,cAAc,EACd,QAAoB,GACrB,EAAE;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiCb,eAAe,CAAC,EACpB,WAAW,EACX,aAAa,EACb,QAAoB,GACrB,EAAE;QACD,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,MAAM,CAAC;IAgCnB,oBAAoB,CAAC,EAAE,YAAY,EAAE,EAAE;QAAE,YAAY,EAAE,UAAU,CAAA;KAAE;;;;IAU7D,aAAa;CAOpB"}

package/src/client/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ERROR_KEYGEN_FAILED = "Error with keygen";
+export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating sui wallet account";
+export declare const ERROR_SIGN_MESSAGE = "Error signing message";
+export declare const ERROR_ACCOUNT_ADDRESS_REQUIRED = "Account address is required";
+export declare const ERROR_VERIFY_MESSAGE_SIGNATURE = "Error verifying message signature";
+export declare const ERROR_VERIFY_TRANSACTION_SIGNATURE = "Error verifying transaction signature";
+//# sourceMappingURL=constants.d.ts.map

package/src/client/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,sCAAsC,CAAC;AAE/E,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E,eAAO,MAAM,8BAA8B,sCACN,CAAC;AAEtC,eAAO,MAAM,kCAAkC,0CACN,CAAC"}

package/src/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/src/utils.d.ts

@@ -0,0 +1,3 @@
+import { IntentScope } from '@mysten/sui/cryptography';
+export declare const formatMessage: (message: string, intentScope: IntentScope) => Uint8Array;
+//# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../packages/src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAqB,MAAM,0BAA0B,CAAC;AAG1E,eAAO,MAAM,aAAa,YACf,MAAM,eACF,WAAW,KACvB,UAeF,CAAC"}