feat: added support for unknown txn types

.changeset/honest-toes-pump.md

@@ -0,0 +1,6 @@
+---
+"@fuel-ts/transactions": patch
+"@fuel-ts/account": patch
+---
+
+feat: added support for unknown txn types

packages/account/src/account.ts

@@ -18,7 +18,6 @@ import type {
   ExcludeResourcesOption,
   Provider,
   ScriptTransactionRequestLike,
-  TransactionResponse,
   TransactionCost,
   EstimateTransactionParams,
   CursorPaginationArgs,
@@ -36,6 +35,8 @@ import {
   ScriptTransactionRequest,
   transactionRequestify,
   addAmountToCoinQuantities,
+  isTransactionTypeUnknown,
+  TransactionResponse,
 } from './providers';
 import {
   cacheRequestInputsResourcesFromOwner,
@@ -632,6 +633,9 @@ export class Account extends AbstractAccount {
       );
     }
     const transactionRequest = transactionRequestify(transactionRequestLike);
+    if (isTransactionTypeUnknown(transactionRequest)) {
+      return new TransactionResponse(transactionRequest, this.provider);
+    }
     if (estimateTxDependencies) {
       await this.provider.estimateTxDependencies(transactionRequest);
     }

packages/account/src/predicate/predicate.ts

@@ -11,6 +11,8 @@ import {
   transactionRequestify,
   isRequestInputResource,
   isRequestInputResourceFromOwner,
+  isTransactionTypeUnknown,
+  TransactionResponse,
 } from '../providers';
 import type {
   CallResult,
@@ -20,7 +22,6 @@ import type {
   Resource,
   TransactionRequest,
   TransactionRequestLike,
-  TransactionResponse,
 } from '../providers';
 
 import { getPredicateRoot } from './utils';
@@ -117,6 +118,9 @@ export class Predicate<
    */
   sendTransaction(transactionRequestLike: TransactionRequestLike): Promise<TransactionResponse> {
     const transactionRequest = transactionRequestify(transactionRequestLike);
+    if (isTransactionTypeUnknown(transactionRequest)) {
+      return Promise.resolve(new TransactionResponse(transactionRequest, this.provider));
+    }
     return super.sendTransaction(transactionRequest, { estimateTxDependencies: false });
   }
 

packages/account/src/providers/provider.test.ts

@@ -16,6 +16,10 @@ import {
   MESSAGE_PROOF_RAW_RESPONSE,
   MESSAGE_PROOF,
 } from '../../test/fixtures';
+import {
+  MOCK_TX_UNKNOWN_RAW_PAYLOAD,
+  MOCK_TX_SCRIPT_RAW_PAYLOAD,
+} from '../../test/fixtures/transaction-summary';
 import { setupTestProviderAndWallets, launchNode, TestMessage } from '../test-utils';
 
 import type { Coin } from './coin';
@@ -56,6 +60,83 @@ const getCustomFetch =
  * @group node
  */
 describe('Provider', () => {
+  it('should throw an error when retrieving a transaction with an unknown transaction type', async () => {
+    using launched = await setupTestProviderAndWallets();
+    const { provider } = launched;
+
+    const mockProvider = await Provider.create(provider.url, {
+      fetch: getCustomFetch('getTransaction', {
+        transaction: {
+          id: '0x1234567890abcdef',
+          rawPayload: MOCK_TX_UNKNOWN_RAW_PAYLOAD, // Unknown transaction type
+        },
+      }),
+    });
+
+    // Spy on console.warn
+    const consoleWarnSpy = vi.spyOn(console, 'warn');
+
+    // Verify that only one transaction was returned (the known type)
+    const transaction = await mockProvider.getTransaction('0x1234567890abcdef');
+
+    expect(transaction).toBeNull();
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Unsupported transaction type encountered')
+    );
+
+    // Clean up
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('should log a warning when retrieving batch transactions with an unknown transaction type', async () => {
+    using launched = await setupTestProviderAndWallets();
+    const { provider: nodeProvider } = launched;
+
+    // Create a mock provider with custom getTransactions operation
+    const mockProvider = await Provider.create(nodeProvider.url, {
+      fetch: getCustomFetch('getTransactions', {
+        transactions: {
+          edges: [
+            {
+              node: {
+                id: '0x1234567890abcdef',
+                rawPayload: MOCK_TX_UNKNOWN_RAW_PAYLOAD,
+              },
+            },
+            {
+              node: {
+                id: '0xabcdef1234567890',
+                rawPayload: MOCK_TX_SCRIPT_RAW_PAYLOAD,
+              },
+            },
+          ],
+          pageInfo: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startCursor: null,
+            endCursor: null,
+          },
+        },
+      }),
+    });
+
+    // Spy on console.warn
+    const consoleWarnSpy = vi.spyOn(console, 'warn');
+
+    // Verify that only one transaction was returned (the known type)
+    const { transactions } = await mockProvider.getTransactions();
+    expect(transactions.length).toBe(1);
+
+    // Check if warning was logged
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Unsupported transaction type encountered')
+    );
+
+    // Clean up
+    consoleWarnSpy.mockRestore();
+  });
+
   it('can getVersion()', async () => {
     using launched = await setupTestProviderAndWallets();
     const { provider } = launched;

packages/account/src/providers/provider.ts

@@ -46,6 +46,7 @@ import type {
 import {
   isTransactionTypeCreate,
   isTransactionTypeScript,
+  isTransactionTypeUnknown,
   transactionRequestify,
 } from './transaction-request';
 import type { TransactionResultReceipt } from './transaction-response';
@@ -739,12 +740,15 @@ Supported fuel-core version: ${supportedVersion}.`
    * @param sendTransactionParams - The provider send transaction parameters (optional).
    * @returns A promise that resolves to the transaction response object.
    */
-  // #region Provider-sendTransaction
   async sendTransaction(
     transactionRequestLike: TransactionRequestLike,
     { estimateTxDependencies = true }: ProviderSendTxParams = {}
   ): Promise<TransactionResponse> {
     const transactionRequest = transactionRequestify(transactionRequestLike);
+    if (isTransactionTypeUnknown(transactionRequest)) {
+      return new TransactionResponse(transactionRequest, this);
+    }
+    // #region Provider-sendTransaction
     if (estimateTxDependencies) {
       await this.estimateTxDependencies(transactionRequest);
     }
@@ -1434,13 +1438,24 @@ Supported fuel-core version: ${supportedVersion}.`
     transactionId: string
   ): Promise<Transaction<TTransactionType> | null> {
     const { transaction } = await this.operations.getTransaction({ transactionId });
+
     if (!transaction) {
       return null;
     }
-    return new TransactionCoder().decode(
-      arrayify(transaction.rawPayload),
-      0
-    )?.[0] as Transaction<TTransactionType>;
+
+    try {
+      return new TransactionCoder().decode(
+        arrayify(transaction.rawPayload),
+        0
+      )?.[0] as Transaction<TTransactionType>;
+    } catch (error) {
+      if (error instanceof FuelError && error.code === ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+        // eslint-disable-next-line no-console
+        console.warn('Unsupported transaction type encountered');
+        return null;
+      }
+      throw error;
+    }
   }
 
   /**
@@ -1454,9 +1469,20 @@ Supported fuel-core version: ${supportedVersion}.`
     } = await this.operations.getTransactions(paginationArgs);
 
     const coder = new TransactionCoder();
-    const transactions = edges.map(
-      ({ node: { rawPayload } }) => coder.decode(arrayify(rawPayload), 0)[0]
-    );
+    const transactions = edges
+      .map(({ node: { rawPayload } }) => {
+        try {
+          return coder.decode(arrayify(rawPayload), 0)[0];
+        } catch (error) {
+          if (error instanceof FuelError && error.code === ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+            // eslint-disable-next-line no-console
+            console.warn('Unsupported transaction type encountered');
+            return null;
+          }
+          throw error;
+        }
+      })
+      .filter((tx): tx is Transaction => tx !== null);
 
     return { transactions, pageInfo };
   }

packages/account/src/providers/transaction-request/index.ts

@@ -4,6 +4,7 @@ export * from './transaction-request';
 export * from './blob-transaction-request';
 export * from './create-transaction-request';
 export * from './script-transaction-request';
+export * from './unknown-transaction-request';
 export * from './errors';
 export * from './scripts';
 export * from './types';

packages/account/src/providers/transaction-request/transaction-request.ts

@@ -11,6 +11,7 @@ import type {
   Policy,
   TransactionCreate,
   TransactionBlob,
+  TransactionUnknown,
 } from '@fuel-ts/transactions';
 import {
   PolicyType,
@@ -192,7 +193,11 @@ export abstract class BaseTransactionRequest implements BaseTransactionRequestLi
     };
   }
 
-  abstract toTransaction(): TransactionCreate | TransactionScript | TransactionBlob;
+  abstract toTransaction():
+    | TransactionCreate
+    | TransactionScript
+    | TransactionBlob
+    | TransactionUnknown;
 
   /**
    * Converts the transaction request to a byte array.

packages/account/src/providers/transaction-request/types.ts

@@ -13,15 +13,18 @@ import type {
   ScriptTransactionRequest,
   ScriptTransactionRequestLike,
 } from './script-transaction-request';
+import type { UnknownTransactionRequest } from './unknown-transaction-request';
 
 export type TransactionRequest =
   | ScriptTransactionRequest
   | CreateTransactionRequest
-  | BlobTransactionRequest;
+  | BlobTransactionRequest
+  | UnknownTransactionRequest;
 export type TransactionRequestLike =
   | ({ type: TransactionType.Script } & ScriptTransactionRequestLike)
   | ({ type: TransactionType.Create } & CreateTransactionRequestLike)
-  | ({ type: TransactionType.Blob } & BlobTransactionRequestLike);
+  | ({ type: TransactionType.Blob } & BlobTransactionRequestLike)
+  | ({ type: TransactionType.Unknown } & UnknownTransactionRequest);
 
 export type JsonAbisFromAllCalls = {
   main: JsonAbi;

packages/account/src/providers/transaction-request/unknown-transaction-request.ts

@@ -0,0 +1,58 @@
+import type { BytesLike } from '@fuel-ts/interfaces';
+import type { TransactionUnknown } from '@fuel-ts/transactions';
+
+import type { BaseTransactionRequestLike } from './transaction-request';
+import { BaseTransactionRequest, TransactionType } from './transaction-request';
+
+/**
+ * @hidden
+ */
+export interface UnknownTransactionRequestLike extends BaseTransactionRequestLike {
+  bytes?: BytesLike;
+}
+/**
+ * @hidden
+ */
+export class UnknownTransactionRequest extends BaseTransactionRequest {
+  static from(obj: UnknownTransactionRequestLike) {
+    if (obj instanceof this) {
+      return obj;
+    }
+    return new this(obj);
+  }
+
+  /** Type of the transaction */
+  type = TransactionType.Unknown as const;
+
+  /** Data of the transaction */
+  bytes?: BytesLike;
+
+  constructor({ bytes, ...rest }: UnknownTransactionRequestLike = {}) {
+    super(rest);
+    this.bytes = bytes;
+  }
+
+  /**
+   * Gets the Transaction Request by hashing the transaction.
+   *
+   * @param chainId - The chain ID.
+   *
+   * @returns - A hash of the transaction, which is the transaction ID.
+   */
+  getTransactionId(): string {
+    return '';
+  }
+
+  /**
+   * Converts the transaction request to a `TransactionBlob`.
+   *
+   * @returns The transaction create object.
+   */
+  toTransaction(): TransactionUnknown {
+    return {
+      ...this.getBaseTransaction(),
+      type: TransactionType.Unknown,
+      bytes: this.bytes,
+    };
+  }
+}

packages/account/src/providers/transaction-request/utils.test.ts

@@ -1,7 +1,13 @@
 import { BlobTransactionRequest } from './blob-transaction-request';
 import { CreateTransactionRequest } from './create-transaction-request';
 import { ScriptTransactionRequest } from './script-transaction-request';
-import { isTransactionTypeBlob, isTransactionTypeCreate, isTransactionTypeScript } from './utils';
+import { UnknownTransactionRequest } from './unknown-transaction-request';
+import {
+  isTransactionTypeBlob,
+  isTransactionTypeCreate,
+  isTransactionTypeScript,
+  isTransactionTypeUnknown,
+} from './utils';
 
 /**
  * @group node
@@ -42,3 +48,15 @@ describe('isTransactionTypeBlob', () => {
     expect(isTransactionTypeCreate(request)).toBe(false);
   });
 });
+
+describe('isTransactionTypeUnknown', () => {
+  it('should return true if the request is an unknown transaction', () => {
+    const request = new UnknownTransactionRequest({ bytes: '0x' });
+    expect(isTransactionTypeUnknown(request)).toBe(true);
+  });
+
+  it('should return false if the request is not an unknown transaction', () => {
+    const request = new ScriptTransactionRequest();
+    expect(isTransactionTypeUnknown(request)).toBe(false);
+  });
+});