diff --git a/packages/api/src/graphql/client.ts b/packages/api/src/graphql/client.ts
index e7a70d05..1305a5d0 100644
--- a/packages/api/src/graphql/client.ts
+++ b/packages/api/src/graphql/client.ts
@@ -6,7 +6,7 @@ import {
 } from "@apollo/client";
 import { setContext } from "@apollo/client/link/context/index.js";
 import { removeTypenameFromVariables } from "@apollo/client/link/remove-typename/index.js";
-import { Context } from "@authentication";
+import { Context } from "../authentication";
 import { collection } from "./collection";
 import { collectionIndex } from "./collection-index";
 import { database } from "./database";
diff --git a/packages/api/src/graphql/database.ts b/packages/api/src/graphql/database.ts
index 5f7d4fb8..72645635 100644
--- a/packages/api/src/graphql/database.ts
+++ b/packages/api/src/graphql/database.ts
@@ -11,6 +11,7 @@ import {
   TPagination,
   TPaginationResponse,
 } from "./types";
+import { TDbTransaction } from "./types/transaction.js";
 
 const DATABASE_CHANGE_OWNER = gql`
   mutation DbChangeOwner($databaseName: String!, $newOwner: String!) {
@@ -20,7 +21,15 @@ const DATABASE_CHANGE_OWNER = gql`
 
 const DATABASE_CREATE = gql`
   mutation DbCreate($databaseName: String!, $merkleHeight: Int!) {
-    dbCreate(databaseName: $databaseName, merkleHeight: $merkleHeight)
+    dbCreate(databaseName: $databaseName, merkleHeight: $merkleHeight) {
+      databaseName
+      transactionType
+      status
+      id
+      tx
+      zkAppPublicKey
+      error
+    }
   }
 `;
 
@@ -102,9 +111,9 @@ export const database = <T>(client: TApolloClient<T>) => ({
     { dbChangeOwner: boolean }
   >(client, DATABASE_CHANGE_OWNER, (data) => data.dbChangeOwner),
   create: createMutateFunction<
-    boolean,
+    TDbTransaction,
     { databaseName: string; merkleHeight: number },
-    { dbCreate: boolean }
+    { dbCreate: TDbTransaction }
   >(client, DATABASE_CREATE, (data) => data.dbCreate),
   setting: createQueryFunction<
     TDatabaseSettings,
diff --git a/packages/api/src/graphql/rollup.ts b/packages/api/src/graphql/rollup.ts
index aa47025b..0b6801c2 100644
--- a/packages/api/src/graphql/rollup.ts
+++ b/packages/api/src/graphql/rollup.ts
@@ -4,10 +4,19 @@ import {
   TCreateRollUpRequest,
   TGetRollUpHistoryResponse,
 } from "./types/rollup.js";
+import { TDbTransaction } from "./types/transaction.js";
 
 const ROLLUP_CREATE = gql`
   mutation CreateRollUp($databaseName: String!) {
-    createRollUp(databaseName: $databaseName)
+    createRollUp(databaseName: $databaseName) {
+      databaseName
+      transactionType
+      status
+      id
+      tx
+      zkAppPublicKey
+      error
+    }
   }
 `;
 
@@ -31,9 +40,9 @@ const ROLLUP_HISTORY_GET = gql`
 `;
 export const rollup = <T>(client: TApolloClient<T>) => ({
   createRollUp: createMutateFunction<
-    boolean,
+    TDbTransaction,
     TCreateRollUpRequest,
-    { createRollUp: boolean }
+    { createRollUp: TDbTransaction }
   >(client, ROLLUP_CREATE, (data) => data.createRollUp),
   getRollUpHistory: createMutateFunction<
     TGetRollUpHistoryResponse,
diff --git a/packages/api/src/graphql/transaction.ts b/packages/api/src/graphql/transaction.ts
index 08071dd6..b404cf1d 100644
--- a/packages/api/src/graphql/transaction.ts
+++ b/packages/api/src/graphql/transaction.ts
@@ -6,6 +6,7 @@ import {
 } from "./common.js";
 import {
   TDbTransaction,
+  TTransactionByIdRequest,
   TTransactionConfirmRequest,
   TTransactionRequest,
 } from "./types/transaction.js";
@@ -25,6 +26,25 @@ const TRANSACTION_GET = gql`
       id
       tx
       zkAppPublicKey
+      error
+    }
+  }
+`;
+
+const TRANSACTION_BY_ID_GET = gql`
+  query GetTransactionById(
+    $id: String!
+  ) {
+    getTransactionById(
+      id: $id
+    ) {
+      databaseName
+      transactionType
+      status
+      id
+      tx
+      zkAppPublicKey
+      error
     }
   }
 `;
@@ -49,6 +69,11 @@ export const transaction = <T>(client: TApolloClient<T>) => ({
     TTransactionRequest,
     { getTransaction: TDbTransaction }
   >(client, TRANSACTION_GET, (data) => data.getTransaction),
+  getTransactionById: createQueryFunction<
+    TDbTransaction,
+    TTransactionByIdRequest,
+    { getTransactionById: TDbTransaction }
+  >(client, TRANSACTION_BY_ID_GET, (data) => data.getTransactionById),
   confirmTransaction: createMutateFunction<
     boolean,
     TTransactionConfirmRequest,
diff --git a/packages/api/src/graphql/types/transaction.ts b/packages/api/src/graphql/types/transaction.ts
index faa305aa..d1fd0f57 100644
--- a/packages/api/src/graphql/types/transaction.ts
+++ b/packages/api/src/graphql/types/transaction.ts
@@ -3,6 +3,11 @@ export type TTransactionRequest = {
   transactionType: "deploy" | "rollup";
 };
 
+export type TTransactionByIdRequest = {
+  id: string;
+};
+
+
 export type TTransactionConfirmRequest = {
   databaseName: string;
   confirmTransactionId: string;
@@ -23,4 +28,5 @@ export type TDbTransaction = {
   transactionType: TTransactionType;
   tx: string;
   zkAppPublicKey: string;
+  error: string;
 };
diff --git a/packages/serverless/src/apollo/app/database.ts b/packages/serverless/src/apollo/app/database.ts
index 1b6c0b0f..e87315f1 100644
--- a/packages/serverless/src/apollo/app/database.ts
+++ b/packages/serverless/src/apollo/app/database.ts
@@ -1,4 +1,9 @@
-import { DB, ModelDatabase, ModelDbSetting } from '@zkdb/storage';
+import {
+  DB,
+  ModelDatabase,
+  ModelDbSetting,
+  withTransaction,
+} from '@zkdb/storage';
 import GraphQLJSON from 'graphql-type-json';
 import Joi from 'joi';
 import {
@@ -107,7 +112,7 @@ extend type Query {
 }
 
 extend type Mutation {
-  dbCreate(databaseName: String!, merkleHeight: Int!): Boolean
+  dbCreate(databaseName: String!, merkleHeight: Int!): DbTransaction
   dbChangeOwner(databaseName: String!, newOwner: String!): Boolean
   dbDeployedUpdate(databaseName: String!, appPublicKey: String!): Boolean
   #dbDrop(databaseName: String!): Boolean
@@ -175,7 +180,14 @@ const dbDeployedUpdate = authorizeWrapper(
 const dbCreate = authorizeWrapper(
   DatabaseCreateRequest,
   async (_root: unknown, args: TDatabaseCreateRequest, ctx) =>
-    createDatabase(args.databaseName, args.merkleHeight, ctx.userName)
+    withTransaction((session) =>
+      createDatabase(
+        args.databaseName,
+        args.merkleHeight,
+        ctx.userName,
+        session
+      )
+    )
 );
 
 const dbChangeOwner = authorizeWrapper(
diff --git a/packages/serverless/src/apollo/app/rollup.ts b/packages/serverless/src/apollo/app/rollup.ts
index 83350a36..d14a949a 100644
--- a/packages/serverless/src/apollo/app/rollup.ts
+++ b/packages/serverless/src/apollo/app/rollup.ts
@@ -38,7 +38,7 @@ type RollUpHistory {
 
 extend type Mutation {
   getRollUpHistory(databaseName: String!): RollUpHistory!
-  createRollUp(databaseName: String!): Boolean
+  createRollUp(databaseName: String!): DbTransaction
 }
 `;
 
diff --git a/packages/serverless/src/apollo/app/transaction.ts b/packages/serverless/src/apollo/app/transaction.ts
index bede9161..95917509 100644
--- a/packages/serverless/src/apollo/app/transaction.ts
+++ b/packages/serverless/src/apollo/app/transaction.ts
@@ -6,30 +6,19 @@ import {
   enqueueTransaction as enqueueTransactionDomain,
   getTransactionForSigning,
   confirmTransaction as confirmTransactionDomain,
+  getTransactionById as getTransactionByIdDomain
 } from '../../domain/use-case/transaction.js';
 import GraphQLJSON from 'graphql-type-json';
+import { ModelDbTransaction, withTransaction } from '@zkdb/storage';
 
 export const typeDefsTransaction = `#graphql
 scalar JSON
 type Query
 type Mutation
 
-enum TransactionType {
-  deploy
-  rollup
-}
-
-type DbTransaction {
-  databaseName: String!
-  transactionType: TransactionType!
-  zkAppPublicKey: String!
-  status: TransactionStatus!
-  tx: String!
-  id: String!
-}
-
 extend type Query {
   getTransaction(databaseName: String!, transactionType: TransactionType!): DbTransaction!
+  getTransactionById(id: String!): DbTransaction
 }
 
 extend type Mutation {
@@ -42,6 +31,10 @@ export type TTransactionRequest = TDatabaseRequest & {
   transactionType: 'deploy' | 'rollup';
 };
 
+export type TTransactionByIdRequest = {
+  id: string;
+};
+
 export type TTransactionIdRequest = TDatabaseRequest & {
   id: string;
 };
@@ -62,7 +55,6 @@ const getTransaction = authorizeWrapper(
       args.transactionType
     );
 
-    transaction.status
     return {
       databaseName: transaction.databaseName,
       transactionType: transaction.transactionType,
@@ -74,17 +66,20 @@ const getTransaction = authorizeWrapper(
   }
 );
 
+const getTransactionById = authorizeWrapper(
+  Joi.object({
+    id: Joi.string().required(),
+  }),
+  async (_root: unknown, args: TTransactionByIdRequest, ctx) => withTransaction((session) => getTransactionByIdDomain(args.id, session))
+);
+
 const enqueueDeployTransaction = authorizeWrapper(
   Joi.object({
     databaseName,
   }),
   async (_root: unknown, args: TDatabaseRequest, ctx) =>
     (
-      await enqueueTransactionDomain(
-        args.databaseName,
-        ctx.userName,
-        'deploy'
-      )
+      await enqueueTransactionDomain(args.databaseName, ctx.userName, 'deploy')
     ).toString()
 );
 
@@ -107,6 +102,7 @@ type TTransactionResolver = {
   JSON: typeof GraphQLJSON;
   Query: {
     getTransaction: typeof getTransaction;
+    getTransactionById: typeof getTransactionById;
   };
   Mutation: {
     enqueueDeployTransaction: typeof enqueueDeployTransaction;
@@ -118,6 +114,7 @@ export const resolversTransaction: TTransactionResolver = {
   JSON: GraphQLJSON,
   Query: {
     getTransaction,
+    getTransactionById
   },
   Mutation: {
     enqueueDeployTransaction,
diff --git a/packages/serverless/src/apollo/app/types/transaction.ts b/packages/serverless/src/apollo/app/types/transaction.ts
index ef1f724b..ee73c616 100644
--- a/packages/serverless/src/apollo/app/types/transaction.ts
+++ b/packages/serverless/src/apollo/app/types/transaction.ts
@@ -9,4 +9,20 @@ enum TransactionStatus {
   success
   unknown
 }
+
+enum TransactionType {
+  deploy
+  rollup
+}
+
+type DbTransaction {
+  databaseName: String!
+  transactionType: TransactionType!
+  zkAppPublicKey: String
+  status: TransactionStatus!
+  tx: String
+  id: String!
+  error: String
+}
+
 `;
diff --git a/packages/serverless/src/domain/use-case/database.ts b/packages/serverless/src/domain/use-case/database.ts
index 247b3250..70c422ee 100644
--- a/packages/serverless/src/domain/use-case/database.ts
+++ b/packages/serverless/src/domain/use-case/database.ts
@@ -24,7 +24,8 @@ import { MinaNetwork } from '@zkdb/smart-contract';
 export async function createDatabase(
   databaseName: string,
   merkleHeight: number,
-  actor: string
+  actor: string,
+  session?: ClientSession
 ) {
   const user = await new ModelUser().findOne({ userName: actor });
 
@@ -44,9 +45,16 @@ export async function createDatabase(
       databaseOwner: actor,
     });
 
-    await enqueueTransaction(databaseName, actor, 'deploy');
+    const id = await enqueueTransaction(databaseName, actor, 'deploy', session);
 
-    return true;
+    const modelTransaction = ModelDbTransaction.getInstance();
+
+    const tx = await modelTransaction.findById(id.toString(), { session });
+
+    return {
+      id: id.toString(),
+      ...tx,
+    };
   }
 
   throw Error(`User ${actor} has not been found`);
diff --git a/packages/serverless/src/domain/use-case/rollup.ts b/packages/serverless/src/domain/use-case/rollup.ts
index e5be272d..bad3be49 100644
--- a/packages/serverless/src/domain/use-case/rollup.ts
+++ b/packages/serverless/src/domain/use-case/rollup.ts
@@ -72,6 +72,15 @@ export async function createRollUp(
     },
     { session: compoundSession?.sessionService }
   );
+
+  const tx = await modelTransaction.findById(txId.toString(), {
+    session: compoundSession?.sessionService,
+  });
+
+  return {
+    id: txId.toString(),
+    ...tx,
+  };
 }
 
 export async function getRollUpHistory(
diff --git a/packages/serverless/src/domain/use-case/transaction.ts b/packages/serverless/src/domain/use-case/transaction.ts
index 5e1a6b5f..bf451e8b 100644
--- a/packages/serverless/src/domain/use-case/transaction.ts
+++ b/packages/serverless/src/domain/use-case/transaction.ts
@@ -78,7 +78,7 @@ export async function enqueueTransaction(
         } else if (onchainTx.txStatus === 'failed') {
           await modelTransaction.updateById(pendingTx._id.toString(), {
             status: 'failed',
-            error: onchainTx.failures.join(" "),
+            error: onchainTx.failures.join(' '),
           });
           // Proceed and create new transaction
         }
@@ -182,6 +182,72 @@ export async function getLatestTransaction(
 
   return txs.length === 0 ? null : txs[0];
 }
+
+export async function getTransactionById(id: string, session?: ClientSession) {
+  const modelTransaction = ModelDbTransaction.getInstance();
+  const transaction = await modelTransaction.findById(id);
+
+  if (!transaction) {
+    throw Error('Transaction has not been found');
+  }
+
+  let status = transaction.status;
+
+  if (transaction.status === 'pending') {
+    if (transaction.txHash) {
+      const zkAppTransaction =
+        await MinaNetwork.getInstance().getZkAppTransactionByTxHash(
+          transaction.txHash
+        );
+
+      if (zkAppTransaction?.txStatus === 'failed') {
+        status = 'failed';
+        await modelTransaction.updateById(
+          id.toString(),
+          {
+            status: 'failed',
+            error: zkAppTransaction.failures.join(' '),
+          },
+          { session }
+        );
+      } else if (zkAppTransaction?.txStatus === 'applied') {
+        status = 'success';
+        await modelTransaction.updateById(
+          id.toString(),
+          {
+            status: 'success',
+          },
+          { session }
+        );
+      }
+    } else {
+      status = 'failed';
+      await modelTransaction.updateById(
+        id.toString(),
+        {
+          status: 'failed',
+          error: 'Transaction hash is missed',
+        },
+        { session }
+      );
+    }
+  }
+
+  if (status !== transaction.status) {
+    const newTransaction = await modelTransaction.findById(id);
+
+    return {
+      id: (newTransaction as any)._id,
+      ...newTransaction,
+    };
+  }
+
+  return {
+    id: (transaction as any)._id,
+    ...transaction,
+  };
+}
+
 export async function confirmTransaction(
   databaseName: string,
   actor: string,
diff --git a/packages/storage/src/database/common/transactions.ts b/packages/storage/src/database/common/transactions.ts
index 1dad587f..7517bc1a 100644
--- a/packages/storage/src/database/common/transactions.ts
+++ b/packages/storage/src/database/common/transactions.ts
@@ -89,6 +89,7 @@ export class ModelDbTransaction extends ModelBasic<DbTransaction> {
       { _id: new ObjectId(id) },
       options
     );
+
     return tx;
   }
 
diff --git a/packages/zkdb/src/index.ts b/packages/zkdb/src/index.ts
index e5fc3c74..608258af 100644
--- a/packages/zkdb/src/index.ts
+++ b/packages/zkdb/src/index.ts
@@ -1,2 +1,4 @@
 export * from './sdk';
 export * from './types';
+
+
diff --git a/packages/zkdb/src/sdk/authentication/authentication.ts b/packages/zkdb/src/sdk/authentication/authentication.ts
index 01420a72..974bed74 100644
--- a/packages/zkdb/src/sdk/authentication/authentication.ts
+++ b/packages/zkdb/src/sdk/authentication/authentication.ts
@@ -105,4 +105,4 @@ export class Authenticator {
   public getAccessToken(): string | undefined {
     return this.#storage.getItem(ZKDB_KEY_ACCESS_TOKEN) || undefined;
   }
-}
+}
\ No newline at end of file
diff --git a/packages/zkdb/src/sdk/global/zkdatabase-client.ts b/packages/zkdb/src/sdk/global/zkdatabase-client.ts
index 55e4b3e5..e468a71f 100644
--- a/packages/zkdb/src/sdk/global/zkdatabase-client.ts
+++ b/packages/zkdb/src/sdk/global/zkdatabase-client.ts
@@ -18,9 +18,7 @@ type MinaConfig = {
  */
 export class ZKDatabaseClient {
   public apiClient: IApiClient;
-
   public authenticator: Authenticator;
-
   public minaConfig: MinaConfig;
 
   private constructor(
diff --git a/packages/zkdb/src/sdk/impl/database.ts b/packages/zkdb/src/sdk/impl/database.ts
index 2f4516d9..7609179a 100644
--- a/packages/zkdb/src/sdk/impl/database.ts
+++ b/packages/zkdb/src/sdk/impl/database.ts
@@ -15,24 +15,30 @@ import {
 } from '../interfaces';
 import { CollectionImpl } from './collection';
 import { ZKGroupImpl } from './group';
+import { ZkDbTransaction } from '../transaction/zkdb-transaction';
+import { Signer } from '../signer';
 
 // TODO: Implement transactions endpoints
 export class ZKDatabaseImpl implements ZKDatabase {
   private databaseName: string;
   private apiClient: IApiClient;
+  private signer: Signer;
 
-  constructor(databaseName: string, apiClient: IApiClient) {
+  constructor(databaseName: string, apiClient: IApiClient, signer: Signer) {
     this.databaseName = databaseName;
     this.apiClient = apiClient;
+    this.signer = signer;
   }
 
-  async create(config: ZKDatabaseConfig): Promise<boolean> {
+  async create(config: ZKDatabaseConfig): Promise<ZkDbTransaction> {
     const result = await this.apiClient.db.create({
       databaseName: this.databaseName,
       merkleHeight: config.merkleHeight,
     });
 
-    return result.unwrap();
+    const dbTransaction = result.unwrap();
+
+    return new ZkDbTransaction(dbTransaction, this.apiClient, this.signer);
   }
 
   async exist(): Promise<boolean> {
@@ -104,28 +110,24 @@ export class ZKDatabaseImpl implements ZKDatabase {
 
   async getTransaction(
     transactionType: TTransactionType
-  ): Promise<TDbTransaction> {
+  ): Promise<ZkDbTransaction> {
     const result = await this.apiClient.transaction.getTransaction({
       databaseName: this.databaseName,
       transactionType,
     });
-    return result.unwrap();
-  }
+    const dbTransaction = result.unwrap();
 
-  async confirmTransaction(id: string, txHash: string): Promise<boolean> {
-    const result = await this.apiClient.transaction.confirmTransaction({
-      databaseName: this.databaseName,
-      confirmTransactionId: id,
-      txHash,
-    });
-    return result.unwrap();
+    return new ZkDbTransaction(dbTransaction, this.apiClient, this.signer);
   }
 
-  async createRollup(): Promise<boolean> {
+  async createRollup(): Promise<ZkDbTransaction> {
     const result = await this.apiClient.rollup.createRollUp({
       databaseName: this.databaseName,
     });
-    return result.unwrap();
+    
+    const dbTransaction = result.unwrap();
+
+    return new ZkDbTransaction(dbTransaction, this.apiClient, this.signer);
   }
 
   async getRollUpHistory(): Promise<TGetRollUpHistory> {
diff --git a/packages/zkdb/src/sdk/interfaces/database.ts b/packages/zkdb/src/sdk/interfaces/database.ts
index e0064f1a..bb146c83 100644
--- a/packages/zkdb/src/sdk/interfaces/database.ts
+++ b/packages/zkdb/src/sdk/interfaces/database.ts
@@ -9,6 +9,7 @@ import {
 } from '../../types';
 import { ZKCollection } from './collection';
 import { ZKGroup } from './group';
+import { ZkDbTransaction } from '../transaction/zkdb-transaction';
 
 export interface ZKDatabaseConfig {
   merkleHeight: number;
@@ -16,7 +17,7 @@ export interface ZKDatabaseConfig {
 
 export interface ZKDatabase {
   // Database
-  create(config: ZKDatabaseConfig): Promise<boolean>;
+  create(config: ZKDatabaseConfig): Promise<ZkDbTransaction>;
 
   exist(): Promise<boolean>;
 
@@ -38,10 +39,9 @@ export interface ZKDatabase {
   getProof(): Promise<JsonProof>;
 
   // Transaction
-  getTransaction(transactionType: TTransactionType): Promise<TDbTransaction>;
-  confirmTransaction(id: string, txHash: string): Promise<boolean>;
+  getTransaction(transactionType: TTransactionType): Promise<ZkDbTransaction>;
 
   // Rollup
-  createRollup(): Promise<boolean>;
+  createRollup(): Promise<ZkDbTransaction>;
   getRollUpHistory(): Promise<TGetRollUpHistory>;
 }
diff --git a/packages/zkdb/src/sdk/signer/browser-signer.ts b/packages/zkdb/src/sdk/signer/browser-signer.ts
index ea8a61a9..72c6e0d8 100644
--- a/packages/zkdb/src/sdk/signer/browser-signer.ts
+++ b/packages/zkdb/src/sdk/signer/browser-signer.ts
@@ -5,10 +5,19 @@ import { SignedData } from '@types';
 import { AuroWallet } from '../wallet/auro-wallet';
 import { TransactionParams } from '../../types/transaction-params';
 
-export class AuroWalletSigner implements Signer {
+export class AuroWalletSigner {
+  private static INSTANCE: AuroWalletSigner;
+
+  public static getInstance() {
+    if (!AuroWalletSigner.INSTANCE) {
+      AuroWalletSigner.INSTANCE = new AuroWalletSigner();
+    }
+
+    return AuroWalletSigner.INSTANCE;
+  }
 
   async signAndSendTransaction(transaction: string, params: TransactionParams): Promise<string> {
-    throw new Error('Method not implemented.');
+   return AuroWallet.signAndSendTransaction(transaction, params)
   }
   async signTransaction(
     transaction: MinaTransaction,
diff --git a/packages/zkdb/src/sdk/signer/nodejs-signer.ts b/packages/zkdb/src/sdk/signer/nodejs-signer.ts
index 2a8e8c95..60254dac 100644
--- a/packages/zkdb/src/sdk/signer/nodejs-signer.ts
+++ b/packages/zkdb/src/sdk/signer/nodejs-signer.ts
@@ -1,5 +1,5 @@
 import { SignedData } from '@types';
-import { MinaNetwork, sendTransaction } from '@zkdb/smart-contract';
+import { sendTransaction } from '@zkdb/smart-contract';
 import Client from 'mina-signer';
 import { fetchAccount, NetworkId, PrivateKey } from 'o1js';
 import { TransactionParams } from '../../types/transaction-params';
@@ -80,4 +80,4 @@ export class NodeSigner implements Signer {
   async signMessage(message: string): Promise<SignedData> {
     return this.client.signMessage(message, this.privateKey.toBase58());
   }
-}
+}
\ No newline at end of file
diff --git a/packages/zkdb/src/sdk/transaction/zkdb-transaction.ts b/packages/zkdb/src/sdk/transaction/zkdb-transaction.ts
new file mode 100644
index 00000000..a93330a6
--- /dev/null
+++ b/packages/zkdb/src/sdk/transaction/zkdb-transaction.ts
@@ -0,0 +1,137 @@
+import { IApiClient } from '@zkdb/api';
+import {
+  TDbTransaction,
+  transactionOrder,
+  TWaitTransactionStatus,
+} from '../../types/transaction';
+import { isBrowser } from '@utils';
+import { PrivateKey } from 'o1js';
+import { AuroWalletSigner, NodeSigner, Signer } from '../signer';
+import { TransactionParams } from '../../types/transaction-params';
+
+const DEFAULT_FEE = 100_000_000;
+
+export class ZkDbTransaction {
+  private transaction: TDbTransaction;
+  private apiClient: IApiClient;
+  private signer: Signer;
+  private txHash: string;
+
+  constructor(
+    transaction: TDbTransaction,
+    apiClient: IApiClient,
+    signer: Signer
+  ) {
+    this.transaction = transaction;
+    this.apiClient = apiClient;
+    this.signer = signer;
+  }
+
+  public async update() {
+    if (
+      this.transaction.status === 'success' ||
+      this.transaction.status === 'failed'
+    ) {
+      throw Error(
+        `Update is unnecessary. Transaction is already ${this.transaction.status}`
+      );
+    }
+
+    const result = await this.apiClient.transaction.getTransactionById({
+      id: this.transaction.id,
+    });
+
+    this.transaction = result.unwrap();
+  }
+
+  public async wait(status: TWaitTransactionStatus) {
+    if (status === this.transaction.status) {
+      return;
+    }
+
+    if (
+      transactionOrder.get(status)! >
+      transactionOrder.get(this.transaction.status)!
+    ) {
+      return new Promise<void>((resolve, reject) => {
+        const checkStatus = async () => {
+          try {
+            await this.update();
+
+            if (this.transaction.status === status) {
+              resolve();
+            } else if (this.transaction.status === 'failed') {
+              throw Error(this.transaction.error);
+            } else {
+              setTimeout(checkStatus, 3000);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        };
+
+        checkStatus();
+      });
+    } else {
+      throw Error('Wrong status order');
+    }
+  }
+
+  public async signAndSend(
+    transactionParams: TransactionParams = {
+      fee: DEFAULT_FEE,
+      memo: '',
+    }
+  ): Promise<string> {
+    if (this.transaction.status !== 'ready') {
+      throw Error('To sign transaction its status must be ready');
+    }
+
+    this.txHash = await this.signer.signAndSendTransaction(
+      this.transaction.tx,
+      transactionParams
+    );
+
+    if (!this.txHash) {
+      throw Error('Failed to acquire transaction hash');
+    }
+
+    const result = await this.apiClient.transaction.confirmTransaction({
+      databaseName: this.transaction.databaseName,
+      confirmTransactionId: this.transaction.id,
+      txHash: this.txHash,
+    });
+
+    const isConfirmed = result.unwrap();
+
+    if (!isConfirmed) {
+      throw Error(`Failed to confirm transaction`);
+    }
+
+    return this.txHash;
+  }
+
+  public async retryConfirm(): Promise<boolean> {
+    if (this.transaction.status === 'ready' && this.txHash) {
+      const result = await this.apiClient.transaction.confirmTransaction({
+        databaseName: this.transaction.databaseName,
+        confirmTransactionId: this.transaction.id,
+        txHash: this.txHash,
+      });
+
+      const isConfirmed = result.unwrap();
+
+      return isConfirmed;
+    } else {
+      return false;
+    }
+  }
+
+  public get status() {
+    return this.transaction.status;
+  }
+
+  public get transactionHash() {
+    return this.txHash;
+  }
+}
diff --git a/packages/zkdb/src/sdk/wallet/auro-wallet.ts b/packages/zkdb/src/sdk/wallet/auro-wallet.ts
index 1bcd3cb8..be278e71 100644
--- a/packages/zkdb/src/sdk/wallet/auro-wallet.ts
+++ b/packages/zkdb/src/sdk/wallet/auro-wallet.ts
@@ -1,14 +1,10 @@
 import { Mina } from 'o1js';
 import { SignedData } from '../../types';
-import { isBrowser } from '@utils';
+import { isBrowser } from '../../utils';
+import { TransactionParams } from '../../types/transaction-params';
 
 type Transaction = Awaited<ReturnType<typeof Mina.transaction>>;
 
-export type TransactionMetadata = {
-  fee: number;
-  memo: string;
-};
-
 export class AuroWallet {
   private constructor() {}
 
@@ -23,8 +19,8 @@ export class AuroWallet {
   }
 
   static async signAndSendTransaction(
-    transaction: Transaction,
-    transactionMetadata: TransactionMetadata = {
+    transaction: string,
+    transactionMetadata: TransactionParams = {
       fee: 0.1,
       memo: '',
     }
@@ -32,7 +28,7 @@ export class AuroWallet {
     this.ensureWalletSupport();
 
     const { hash } = await (window as any).mina.sendTransaction({
-      transaction: transaction.toJSON(),
+      transaction: transaction,
       feePayer: {
         fee: transactionMetadata.fee,
         memo: transactionMetadata.memo,
@@ -44,7 +40,7 @@ export class AuroWallet {
 
   static async signTransaction(
     transaction: Transaction,
-    transactionMetadata: TransactionMetadata = {
+    transactionMetadata: TransactionParams = {
       fee: 0.1,
       memo: '',
     }
diff --git a/packages/zkdb/src/types/transaction.ts b/packages/zkdb/src/types/transaction.ts
index 91708d56..2dd577ce 100644
--- a/packages/zkdb/src/types/transaction.ts
+++ b/packages/zkdb/src/types/transaction.ts
@@ -1,4 +1,5 @@
 export type TTransactionType = 'deploy' | 'rollup';
+
 export type TTransactionStatus =
   | 'start'
   | 'ready'
@@ -6,6 +7,12 @@ export type TTransactionStatus =
   | 'failed'
   | 'success'
   | 'unknown';
+
+export type TWaitTransactionStatus = Exclude<
+  TTransactionStatus,
+  'start' | 'unknown' | 'failed'
+>;
+
 export type TDbTransaction = {
   id: string;
   databaseName: string;
@@ -13,4 +20,14 @@ export type TDbTransaction = {
   transactionType: TTransactionType;
   tx: string;
   zkAppPublicKey: string;
+  error: string
 };
+
+export const transactionOrder: Map<TTransactionStatus, number> = new Map([
+  ['start', 0],
+  ['ready', 1],
+  ['pending', 2],
+  ['success', 3],
+  ['failed', -1],
+  ['unknown', -2],
+]);