Transfer from starknet to starknet-kit

frontend/src/services/contract.js

@@ -1,23 +1,35 @@
-import { connect } from 'get-starknet';
+import { connect } from 'starknetkit';
 import { getDeployContractData } from '../utils/constants';
 import { axiosInstance } from '../utils/axios';
 
 export async function deployContract(walletId) {
   try {
-    // Connect to Starknet wallet
+    console.log('Connecting to StarkNet wallet...');
+    // Connect to StarkNet wallet
     const starknet = await connect();
-    if (!starknet.isConnected) {
+
+    // Ensure the wallet connection is successful
+    if (!starknet || !starknet.isConnected) {
       throw new Error('Wallet not connected');
     }
 
+    console.log('Wallet connected:');
+
     // Prepare the deploy contract transaction object
     const deployContractTransaction = getDeployContractData(walletId);
+    if (!deployContractTransaction) {
+      throw new Error('Failed to retrieve contract deployment data');
+    }
 
     // Execute the deployment transaction
-    // const result = await starknet.account.execute([deployContractTransaction]);
+    console.log('Deploying contract...');
     const result = await starknet.account.deployContract(deployContractTransaction);
     console.log('Contract deployed successfully:', result);
+
+    // Wait for the transaction to be confirmed
     await starknet.account.waitForTransaction(result.transaction_hash);
+    console.log('Transaction confirmed:', result.transaction_hash);
+
     return {
       transactionHash: result.transaction_hash,
       contractAddress: result.contract_address,
@@ -31,17 +43,20 @@ export async function deployContract(walletId) {
 export async function checkAndDeployContract(walletId) {
   try {
     console.log('Checking if contract is deployed for wallet ID:', walletId);
+
+    // Check if the contract is deployed by querying the backend
     const response = await axiosInstance.get(`/api/check-user?wallet_id=${walletId}`);
     console.log('Backend response:', response.data);
 
+    // If the contract is not deployed, deploy it
     if (!response.data.is_contract_deployed) {
       console.log('Contract not deployed. Deploying...');
       const result = await deployContract(walletId);
       const contractAddress = result.contractAddress;
 
       console.log('Contract address:', contractAddress);
 
-      // Update the backend with transaction hash and wallet ID
+      // Update the backend with deployment information
       await axiosInstance.post(`/api/update-user-contract`, {
         wallet_id: walletId,
         contract_address: contractAddress,
@@ -52,5 +67,6 @@ export async function checkAndDeployContract(walletId) {
     }
   } catch (error) {
     console.error('Error checking contract status:', error);
+    throw error;
   }
 }

frontend/src/services/transaction.js

@@ -1,4 +1,4 @@
-import { connect } from 'get-starknet';
+import { connect } from 'starknetkit';
 import { CallData } from 'starknet';
 import { erc20abi } from '../abis/erc20';
 import { abi } from '../abis/abi';

frontend/src/services/wallet.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { connect } from 'get-starknet';
+import { connect } from 'starknetkit';
 import { ETH_ADDRESS, STRK_ADDRESS, USDC_ADDRESS } from '../utils/constants';
 import { ReactComponent as ETH } from 'assets/icons/ethereum.svg';
 import { ReactComponent as USDC } from 'assets/icons/borrow_usdc.svg';

frontend/test/__mocks__/starknetkit.js

@@ -0,0 +1,17 @@
+module.exports = {
+  connect: jest.fn(() =>
+    Promise.resolve({
+      address: '0xMockedAddress12345',
+      chainId: 'mocked-chain-id',
+    })
+  ),
+
+  disconnect: jest.fn(() => Promise.resolve(true)),
+
+  getNetwork: jest.fn(() =>
+    Promise.resolve({
+      network: 'MockedNetwork',
+      rpcUrl: 'https://mocked.rpc.url',
+    })
+  ),
+};

frontend/test/services/contract.test.js

@@ -1,13 +1,15 @@
-import { connect } from 'get-starknet';
+import { connect } from 'starknetkit';
 import { axiosInstance } from '../../src/utils/axios';
 import { deployContract, checkAndDeployContract } from '../../src/services/contract';
 import { getDeployContractData } from '../../src/utils/constants';
 
-jest.mock('get-starknet');
+jest.mock('starknetkit');
 jest.mock('../../src/utils/axios');
 jest.mock('../../src/utils/constants');
 
 describe('Contract Deployment Tests', () => {
+  jest.setTimeout(15000);
+
   const mockWalletId = '0x123...';
   const mockTransactionHash = '0xabc...';
   const mockContractAddress = '0xdef...';
@@ -22,22 +24,21 @@ describe('Contract Deployment Tests', () => {
 
   describe('deployContract', () => {
     it('should successfully deploy contract', async () => {
-      jest.setTimeout(10000);
       const mockStarknet = {
         isConnected: true,
         account: {
           deployContract: jest.fn().mockResolvedValue({
             transaction_hash: mockTransactionHash,
             contract_address: mockContractAddress,
           }),
-          waitForTransaction: jest.fn().mockResolvedValue(true),
+          waitForTransaction: jest.fn().mockResolvedValue({ status: 'ACCEPTED_ON_L2' }),
         },
       };
+
       connect.mockResolvedValue(mockStarknet);
 
       const result = await deployContract(mockWalletId);
 
-      expect(connect).toHaveBeenCalled();
       expect(mockStarknet.account.deployContract).toHaveBeenCalledWith({
         contractData: 'mockContractData',
       });
@@ -58,7 +59,7 @@ describe('Contract Deployment Tests', () => {
       await expect(deployContract(mockWalletId)).rejects.toThrow('Wallet not connected');
     });
 
-    it('should handle deployment errors correctly', async () => {
+    it('should handle deployment errors', async () => {
       const mockError = new Error('Deployment failed');
       connect.mockRejectedValue(mockError);
 
@@ -79,7 +80,7 @@ describe('Contract Deployment Tests', () => {
             transaction_hash: mockTransactionHash,
             contract_address: mockContractAddress,
           }),
-          waitForTransaction: jest.fn().mockResolvedValue(true),
+          waitForTransaction: jest.fn().mockResolvedValue({ status: 'ACCEPTED_ON_L2' }),
         },
       };
       connect.mockResolvedValue(mockStarknet);
@@ -89,7 +90,6 @@ describe('Contract Deployment Tests', () => {
       await checkAndDeployContract(mockWalletId);
 
       expect(axiosInstance.get).toHaveBeenCalledWith(`/api/check-user?wallet_id=${mockWalletId}`);
-      expect(connect).toHaveBeenCalled();
       expect(mockStarknet.account.deployContract).toHaveBeenCalledWith({
         contractData: 'mockContractData',
       });
@@ -106,23 +106,23 @@ describe('Contract Deployment Tests', () => {
 
       await checkAndDeployContract(mockWalletId);
 
-      expect(axiosInstance.get).toHaveBeenCalled();
+      expect(axiosInstance.get).toHaveBeenCalledWith(`/api/check-user?wallet_id=${mockWalletId}`);
       expect(connect).not.toHaveBeenCalled();
       expect(axiosInstance.post).not.toHaveBeenCalled();
     });
 
-    it('should handle backend check errors correctly', async () => {
+    it('should handle backend check errors', async () => {
       const mockError = new Error('Backend error');
       axiosInstance.get.mockRejectedValue(mockError);
 
       console.error = jest.fn();
 
-      await checkAndDeployContract(mockWalletId);
+      await expect(checkAndDeployContract(mockWalletId)).rejects.toThrow('Backend error');
 
       expect(console.error).toHaveBeenCalledWith('Error checking contract status:', mockError);
     });
 
-    it('should handle contract update error correctly after deployment', async () => {
+    it('should handle contract update failures', async () => {
       axiosInstance.get.mockResolvedValue({
         data: { is_contract_deployed: false },
       });
@@ -134,7 +134,7 @@ describe('Contract Deployment Tests', () => {
             transaction_hash: mockTransactionHash,
             contract_address: mockContractAddress,
           }),
-          waitForTransaction: jest.fn().mockResolvedValue(true),
+          waitForTransaction: jest.fn().mockResolvedValue({ status: 'ACCEPTED_ON_L2' }),
         },
       };
       connect.mockResolvedValue(mockStarknet);
@@ -144,9 +144,9 @@ describe('Contract Deployment Tests', () => {
 
       console.error = jest.fn();
 
-      await checkAndDeployContract(mockWalletId);
+      await expect(checkAndDeployContract(mockWalletId)).rejects.toThrow('Update failed');
 
       expect(console.error).toHaveBeenCalledWith('Error checking contract status:', mockUpdateError);
     });
   });
-});
+});