@subwallet/extension-base 1.3.73-0 → 1.3.74-0

package/types/account/info/keyring.js

@@ -34,6 +34,11 @@
  * @prop {string} [derivationPath] - Derivation path
  * */
 
+/**
+ * @interface AccountMultisigData
+ * @prop {boolean} [isMultisig] - Is multisig account
+ * */
+
 /**
  * Represents the comprehensive metadata associated with an account, combining various aspects of account data.
  * This interface extends from multiple specific metadata interfaces to provide a unified view of an account's metadata.
@@ -56,6 +61,7 @@ export let AccountSignMode;
   AccountSignMode["GENERIC_LEDGER"] = "generic-ledger";
   AccountSignMode["ECDSA_SUBSTRATE_LEDGER"] = "ecdsa-substrate-ledger";
   AccountSignMode["READ_ONLY"] = "readonly";
+  AccountSignMode["MULTISIG"] = "multisig";
   AccountSignMode["ALL_ACCOUNT"] = "all";
   AccountSignMode["INJECTED"] = "injected";
   AccountSignMode["UNKNOWN"] = "unknown";

package/types/account/info/proxy.d.ts

@@ -30,6 +30,7 @@ export declare enum AccountProxyType {
     SOLO = "solo",
     UNIFIED = "unified",
     QR = "qr",
+    MULTISIG = "multisig",
     LEDGER = "ledger",
     READ_ONLY = "readonly",
     INJECTED = "injected",

package/types/account/info/proxy.js

@@ -39,6 +39,7 @@ export let AccountProxyType;
   AccountProxyType["SOLO"] = "solo";
   AccountProxyType["UNIFIED"] = "unified";
   AccountProxyType["QR"] = "qr";
+  AccountProxyType["MULTISIG"] = "multisig";
   AccountProxyType["LEDGER"] = "ledger";
   AccountProxyType["READ_ONLY"] = "readonly";
   AccountProxyType["INJECTED"] = "injected";

package/types/multisig/index.d.ts

@@ -0,0 +1,76 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { MultisigTxType } from '@subwallet/extension-base/services/multisig-service';
+import { DecodeCallDataResponse } from '@subwallet/extension-base/services/multisig-service/utils';
+import { BaseRequestSign } from '@subwallet/extension-base/types';
+import { HexString } from '@polkadot/util/types';
+export interface PendingMultisigTxRequest extends BaseRequestSign {
+    address: string;
+    chain: string;
+    multisigMetadata: MultisigRawMetadata;
+    callHash: string;
+    decodedCallData?: DecodeCallDataResponse;
+    type: MultisigTxType;
+    call: string;
+}
+export interface ApprovePendingTxRequest extends PendingMultisigTxRequest {
+    timepoint?: {
+        height: number;
+        index: number;
+    };
+}
+export interface ExecutePendingTxRequest extends PendingMultisigTxRequest {
+    timepoint?: {
+        height: number;
+        index: number;
+    };
+}
+export interface CancelPendingTxRequest extends PendingMultisigTxRequest {
+    timepoint: {
+        height: number;
+        index: number;
+    };
+}
+export interface InitMultisigTxRequest {
+    transactionId: string;
+    signer: string;
+    chain: string;
+    multisigMetadata: MultisigRawMetadata;
+}
+export interface InitMultisigTxResponse {
+    submittedCallData: HexString;
+    callData: HexString;
+    decodedCallData: DecodeCallDataResponse | undefined;
+    depositAmount: string;
+    networkFee: string;
+    error?: SelectSignatoryError;
+}
+export interface RequestGetSignableAccountInfos {
+    multisigProxyId: string;
+    chain: string;
+    extrinsicType: ExtrinsicType;
+}
+export interface SignableAccountInfo {
+    proxyId: string;
+    address: string;
+}
+export interface ResponseGetSignableAccountInfos {
+    signableProxies: SignableAccountInfo[];
+}
+export interface MultisigRawMetadata {
+    signers: string[];
+    threshold: number;
+    multisigAddress: string;
+}
+export interface MultisigAccountInfo {
+    multisigAddress: string;
+    signers: string[];
+    threshold: number;
+}
+export declare enum SelectSignatoryErrorType {
+    NOT_ENOUGH_BALANCE = "NOT_ENOUGH_BALANCE",
+    NOT_ENOUGH_DEPOSIT = "NOT_ENOUGH_DEPOSIT"
+}
+export interface SelectSignatoryError {
+    errorType: SelectSignatoryErrorType;
+    message: string;
+}

package/types/multisig/index.js

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export let SelectSignatoryErrorType;
+(function (SelectSignatoryErrorType) {
+  SelectSignatoryErrorType["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
+  SelectSignatoryErrorType["NOT_ENOUGH_DEPOSIT"] = "NOT_ENOUGH_DEPOSIT";
+})(SelectSignatoryErrorType || (SelectSignatoryErrorType = {}));

package/types/notification/index.d.ts

@@ -2,6 +2,10 @@ import { NotificationTab } from '@subwallet/extension-base/services/inapp-notifi
 export interface GetNotificationParams {
     proxyId: string;
     notificationTab: NotificationTab;
+    metadata?: {
+        multisigAddress?: string;
+        chain?: string;
+    };
 }
 export interface RequestSwitchStatusParams {
     id: string;
@@ -12,3 +16,7 @@ export interface RequestIsClaimedPolygonBridge {
     counter: number;
     sourceNetwork: number;
 }
+export interface MarkAllReadParams {
+    proxyId: string;
+    excludeNotificationIds?: string[];
+}

package/types/substrateProxyAccount/index.d.ts

@@ -1,6 +1,8 @@
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { AnyJson } from '@polkadot/types/types';
+import { HexString } from '@polkadot/util/types';
 export interface ExcludedSubstrateProxyAccounts {
-    address: string;
+    substrateProxyAddress: string;
     substrateProxyType: SubstrateProxyType;
 }
 export interface RequestGetSubstrateProxyAccountGroup {
@@ -20,4 +22,27 @@ export interface SubstrateProxyAccountGroup {
     substrateProxyAccounts: SubstrateProxyAccountItem[];
     substrateProxyDeposit: string;
 }
+interface ProxyRawMetadata {
+    proxiedAddress: string;
+}
+export interface HandleSubstrateProxyWrappedTxRequest {
+    transactionId: string;
+    signer: string;
+    chain: string;
+    proxyMetadata: ProxyRawMetadata;
+    previousWrappedTxId?: string;
+}
+export interface DecodeCallDataResponse {
+    /** Method name of the call */
+    method: string;
+    /** Section/pallet name of the call */
+    section: string;
+    /** Decoded arguments of the call */
+    args: AnyJson;
+}
+export interface HandleSubstrateProxyWrappedTxResponse {
+    submittedCallData: HexString;
+    networkFee: string;
+    decodedCallData: DecodeCallDataResponse | undefined;
+}
 export * from './actions';

package/types/transaction/error.d.ts

@@ -38,4 +38,9 @@ export declare enum TransferTxErrorType {
     RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT",
     RECEIVER_ACCOUNT_INACTIVE = "RECEIVER_ACCOUNT_INACTIVE"
 }
-export declare type TransactionErrorType = BasicTxErrorType | TransferTxErrorType | StakingTxErrorType | YieldValidationStatus | SwapErrorType;
+export declare enum MultisigTxErrorType {
+    INVALID_PARAMS = "INVALID_PARAMS",
+    LACK_MULTISIG_PALLET = "LACK_MULTISIG_PALLET",
+    UNABLE_TO_CONSTRUCT_TX = "UNABLE_TO_CONSTRUCT_TX"
+}
+export declare type TransactionErrorType = BasicTxErrorType | TransferTxErrorType | StakingTxErrorType | YieldValidationStatus | SwapErrorType | MultisigTxErrorType;

package/types/transaction/error.js

@@ -43,4 +43,10 @@ export let TransferTxErrorType;
   TransferTxErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
   TransferTxErrorType["RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
   TransferTxErrorType["RECEIVER_ACCOUNT_INACTIVE"] = "RECEIVER_ACCOUNT_INACTIVE";
-})(TransferTxErrorType || (TransferTxErrorType = {}));
+})(TransferTxErrorType || (TransferTxErrorType = {}));
+export let MultisigTxErrorType;
+(function (MultisigTxErrorType) {
+  MultisigTxErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  MultisigTxErrorType["LACK_MULTISIG_PALLET"] = "LACK_MULTISIG_PALLET";
+  MultisigTxErrorType["UNABLE_TO_CONSTRUCT_TX"] = "UNABLE_TO_CONSTRUCT_TX";
+})(MultisigTxErrorType || (MultisigTxErrorType = {}));

package/types/transaction/request.d.ts

@@ -2,7 +2,6 @@ import { TransactionFee } from '../fee';
 import { TransactionWarningType } from './warning';
 export declare type BaseRequestSign = {
     ignoreWarnings?: TransactionWarningType[];
-    signerSubstrateProxyAddress?: string;
 };
 export declare type InternalRequestSign<T> = T & BaseRequestSign;
 export interface RequestBaseTransfer {

package/utils/account/transform.js

@@ -71,6 +71,8 @@ export const getAccountSignMode = (address, _meta) => {
           }
         } else if (meta.isReadOnly) {
           return AccountSignMode.READ_ONLY;
+        } else if (meta.isMultisig) {
+          return AccountSignMode.MULTISIG;
         } else {
           return AccountSignMode.QR;
         }
@@ -157,13 +159,14 @@ const EARN_VMANTA_ACTIONS = [ExtrinsicType.MINT_VMANTA, ExtrinsicType.REDEEM_VMA
 const EVM_ACTIONS = [ExtrinsicType.TOKEN_SPENDING_APPROVAL, ExtrinsicType.EVM_EXECUTE];
 const CLAIM_AVAIL_BRIDGE = [ExtrinsicType.CLAIM_BRIDGE];
 const OPEN_GOV_ACTIONS = [ExtrinsicType.GOV_VOTE, ExtrinsicType.GOV_UNVOTE, ExtrinsicType.GOV_UNLOCK_VOTE];
-const SUBSTRATE_PROXY_ACTION = [ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT, ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT];
+const MULTISIG_ACTIONS = [ExtrinsicType.MULTISIG_APPROVE_TX, ExtrinsicType.MULTISIG_EXECUTE_TX, ExtrinsicType.MULTISIG_CANCEL_TX, ExtrinsicType.MULTISIG_INIT_TX];
+const SUBSTRATE_PROXY_ACTION = [ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT, ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT, ExtrinsicType.SUBSTRATE_PROXY_INIT_TX];
 const OTHER_ACTIONS = [ExtrinsicType.TRANSFER_XCM, ExtrinsicType.SEND_NFT, ExtrinsicType.SWAP, ExtrinsicType.CROWDLOAN];
 export const getAccountTransactionActions = (signMode, networkType, type, _meta, _specialNetwork) => {
   if ([AccountSignMode.PASSWORD, AccountSignMode.INJECTED].includes(signMode)) {
     switch (networkType) {
       case AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...MULTISIG_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...SUBSTRATE_PROXY_ACTION, ...EVM_ACTIONS];
       case AccountChainType.TON:
@@ -176,7 +179,7 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
   } else if (signMode === AccountSignMode.QR) {
     switch (networkType) {
       case AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...MULTISIG_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
         return [...(isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
       case AccountChainType.TON:
@@ -186,12 +189,31 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
       case AccountChainType.BITCOIN:
         return [];
     }
+  } else if (signMode === AccountSignMode.MULTISIG) {
+    switch (networkType) {
+      case AccountChainType.SUBSTRATE:
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS,
+        // ...EARN_VDOT_ACTIONS, // todo: consider support this
+        // ...EARN_LDOT_ACTIONS,
+        // ...EARN_SDOT_ACTIONS,
+        // ...EARN_QDOT_ACTIONS,
+        // ...EARN_VMANTA_ACTIONS,
+        ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ExtrinsicType.SEND_NFT];
+      case AccountChainType.ETHEREUM:
+        return [];
+      case AccountChainType.TON:
+        return [];
+      case AccountChainType.CARDANO:
+        return [];
+      case AccountChainType.BITCOIN:
+        return [];
+    }
   } else if (signMode === AccountSignMode.GENERIC_LEDGER) {
     switch (networkType) {
       case AccountChainType.SUBSTRATE:
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS,
         // ...EARN_QDOT_ACTIONS,
-        ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
+        ...OPEN_GOV_ACTIONS, ...MULTISIG_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
         return [...BASE_TRANSFER_ACTIONS, ...EARN_STDOT_ACTIONS, ...EVM_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ExtrinsicType.STAKING_WITHDRAW,
         // For liquid staking
@@ -366,6 +388,8 @@ export const convertAccountProxyType = accountSignMode => {
       return AccountProxyType.LEDGER;
     case AccountSignMode.QR:
       return AccountProxyType.QR;
+    case AccountSignMode.MULTISIG:
+      return AccountProxyType.MULTISIG;
     case AccountSignMode.READ_ONLY:
       return AccountProxyType.READ_ONLY;
     case AccountSignMode.INJECTED:

package/utils/logger/Logger.d.ts

@@ -0,0 +1,31 @@
+import { LoggerConfig, LogLevel, StructuredLogData } from './types';
+export declare class Logger {
+    private logInstance;
+    private name;
+    private config;
+    private groupStack;
+    constructor(config: LoggerConfig);
+    private getLogLevelNumber;
+    private shouldLog;
+    private formatMessage;
+    error(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    log(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    trace(message: string, ...args: unknown[]): void;
+    group(label?: string): void;
+    groupEnd(): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    getName(): string;
+    private createLogContext;
+    private logStructured;
+    errorStructured(data: StructuredLogData): void;
+    warnStructured(data: StructuredLogData): void;
+    infoStructured(data: StructuredLogData): void;
+    debugStructured(data: StructuredLogData): void;
+    traceStructured(data: StructuredLogData): void;
+    logStructuredPublic(data: StructuredLogData): void;
+    noop(...values: unknown[]): void;
+}

package/utils/logger/Logger.js

@@ -0,0 +1,267 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import log from 'loglevel';
+const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
+const branchName = process.env.BRANCH_NAME || 'koni-dev';
+const isProduction = PRODUCTION_BRANCHES.indexOf(branchName) > -1;
+const LOG_LEVELS = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+export class Logger {
+  groupStack = [];
+  constructor(config) {
+    var _config$enableStructu;
+    this.name = config.name;
+    this.config = {
+      name: config.name,
+      level: config.level || (isProduction ? 'info' : 'debug'),
+      enableStructuredLogging: (_config$enableStructu = config.enableStructuredLogging) !== null && _config$enableStructu !== void 0 ? _config$enableStructu : false,
+      enableContextCapture: config.enableContextCapture || !isProduction
+    };
+
+    // Create a named logger instance
+    this.logInstance = log.getLogger(this.name);
+    this.logInstance.setLevel(this.getLogLevelNumber(this.config.level));
+  }
+  getLogLevelNumber(level) {
+    return LOG_LEVELS[level];
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= this.getLogLevelNumber(this.config.level);
+  }
+  formatMessage(level, message, ...args) {
+    const prefix = `[${this.name}] [${level.toUpperCase()}]`;
+    return `${prefix} ${message}`;
+  }
+
+  // Simple logging methods (drop-in console replacement)
+  error(message, ...args) {
+    if (!this.shouldLog('error')) {
+      return;
+    }
+    const formatted = this.formatMessage('error', message);
+    this.logInstance.error(formatted, ...args);
+
+    // Add breadcrumb for errors
+    if (args.length > 0 && args[0] instanceof Error) {
+      // sentryAdapter.captureException(args[0] as Error, {
+      //   message,
+      //   logger: this.name
+      // });
+    } else {
+      // sentryAdapter.addBreadcrumb(message, 'error', {
+      //   logger: this.name,
+      //   args: args.length > 0 ? args : undefined
+      // });
+    }
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog('warn')) {
+      return;
+    }
+    const formatted = this.formatMessage('warn', message);
+    this.logInstance.warn(formatted, ...args);
+    // sentryAdapter.addBreadcrumb(message, 'warn', {
+    //   logger: this.name,
+    //   args: args.length > 0 ? args : undefined
+    // });
+  }
+  info(message, ...args) {
+    if (!this.shouldLog('info')) {
+      return;
+    }
+    const formatted = this.formatMessage('info', message);
+    this.logInstance.info(formatted, ...args);
+    // sentryAdapter.addBreadcrumb(message, 'info', {
+    //   logger: this.name,
+    //   args: args.length > 0 ? args : undefined
+    // });
+  }
+  log(message, ...args) {
+    this.info(message, ...args);
+  }
+  debug(message, ...args) {
+    if (!this.shouldLog('debug')) {
+      return;
+    }
+    const formatted = this.formatMessage('debug', message);
+    this.logInstance.debug(formatted, ...args);
+    // sentryAdapter.addBreadcrumb(message, 'debug', {
+    //   logger: this.name,
+    //   args: args.length > 0 ? args : undefined
+    // });
+  }
+  trace(message, ...args) {
+    if (!this.shouldLog('trace')) {
+      return;
+    }
+    const formatted = this.formatMessage('trace', message);
+    this.logInstance.trace(formatted, ...args);
+    // sentryAdapter.addBreadcrumb(message, 'trace', {
+    //   logger: this.name,
+    //   args: args.length > 0 ? args : undefined
+    // });
+  }
+
+  // Group methods
+  group(label) {
+    const groupLabel = label || `Group ${this.groupStack.length + 1}`;
+    this.groupStack.push(groupLabel);
+    if (this.shouldLog('debug')) {
+      const indent = '  '.repeat(this.groupStack.length - 1);
+      const formatted = this.formatMessage('debug', `${indent}▼ ${groupLabel}`);
+      this.logInstance.debug(formatted);
+    }
+  }
+  groupEnd() {
+    if (this.groupStack.length === 0) {
+      return;
+    }
+    const groupLabel = this.groupStack.pop();
+    if (!groupLabel) {
+      return;
+    }
+    if (this.shouldLog('debug')) {
+      const indent = '  '.repeat(this.groupStack.length);
+      const formatted = this.formatMessage('debug', `${indent}▲ ${groupLabel}`);
+      this.logInstance.debug(formatted);
+    }
+  }
+
+  // Utility methods
+  setLevel(level) {
+    this.config.level = level;
+    this.logInstance.setLevel(this.getLogLevelNumber(level));
+  }
+  getLevel() {
+    return this.config.level;
+  }
+  getName() {
+    return this.name;
+  }
+
+  // Structured logging methods
+  // Noted: Capturing context is expensive due to Error creation and stack parsing; it should only be used when necessary.
+  createLogContext(level) {
+    const baseContext = {
+      timestamp: new Date().toISOString(),
+      level,
+      loggerName: this.name
+    };
+    if (this.config.enableContextCapture) {
+      const extracted = extractContext(3);
+      if (extracted) {
+        return {
+          ...baseContext,
+          ...extracted
+        };
+      }
+    }
+    return baseContext;
+  }
+  logStructured(level, data) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const context = this.createLogContext(level);
+    const logEntry = {
+      ...context,
+      message: data.message,
+      context: data.context,
+      error: data.error instanceof Error ? {
+        name: data.error.name,
+        message: data.error.message,
+        stack: data.error.stack
+      } : data.error,
+      tags: data.tags,
+      extra: data.extra
+    };
+
+    // Output structured JSON
+    const jsonOutput = JSON.stringify(logEntry, null, 2);
+    this.logInstance[level](jsonOutput);
+
+    // Add breadcrumb to Sentry
+    if (data.error instanceof Error) {
+      // sentryAdapter.captureException(data.error, {
+      //   ...data.context,
+      //   logger: this.name,
+      //   tags: data.tags
+      // });
+    } else {
+      // sentryAdapter.addBreadcrumb(data.message, level, {
+      //   ...data.context,
+      //   logger: this.name,
+      //   tags: data.tags
+      // });
+    }
+  }
+  errorStructured(data) {
+    this.logStructured('error', data);
+  }
+  warnStructured(data) {
+    this.logStructured('warn', data);
+  }
+  infoStructured(data) {
+    this.logStructured('info', data);
+  }
+  debugStructured(data) {
+    this.logStructured('debug', data);
+  }
+  traceStructured(data) {
+    this.logStructured('trace', data);
+  }
+
+  // Public alias for backward compatibility (calls infoStructured)
+  logStructuredPublic(data) {
+    this.infoStructured(data);
+  }
+
+  // Polkadot compatibility - noop method
+  noop(...values) {
+    // No operation - required by Polkadot Logger interface
+  }
+}
+
+/**
+ * Extract context from Error stack trace
+ * @Todo: Use for structured log, re-test before using
+ */
+function extractContext(skipFrames = 2) {
+  try {
+    const stack = new Error().stack;
+    if (!stack) {
+      return null;
+    }
+    const lines = stack.split('\n');
+    // Skip Error constructor and extractContext call
+    const frame = lines[skipFrames + 1];
+    if (!frame) {
+      return null;
+    }
+
+    // Match patterns like: "at functionName (file://path/to/file.ts:123:45)"
+    const match = frame.match(/at\s+(?:async\s+)?(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+    if (match) {
+      const [, functionName, filePath, line, column] = match;
+      const fileName = filePath.split('/').pop() || filePath;
+      return {
+        file: fileName,
+        function: functionName,
+        line: parseInt(line, 10),
+        column: parseInt(column, 10),
+        timestamp: new Date().toISOString(),
+        level: 'info',
+        loggerName: ''
+      };
+    }
+  } catch {
+    // Ignore errors in context extraction
+  }
+  return null;
+}

package/utils/logger/index.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from './Logger';
+import { LoggerConfig } from './types';
+/**
+ * Create a named logger instance
+ * @param name - Logger name (typically the class or module name)
+ * @param config - Optional logger configuration
+ * @returns Logger instance
+ */
+export declare function createLogger(name: string, config?: Partial<LoggerConfig>): Logger;
+/**
+ * Default logger instance
+ */
+export declare const defaultLogger: Logger;
+export type { LogLevel, LoggerConfig, LogContext, StructuredLogData } from './types';
+export { Logger } from './Logger';

package/utils/logger/index.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Logger } from "./Logger.js";
+/**
+ * Create a named logger instance
+ * @param name - Logger name (typically the class or module name)
+ * @param config - Optional logger configuration
+ * @returns Logger instance
+ */
+export function createLogger(name, config) {
+  return new Logger({
+    name,
+    ...config
+  });
+}
+
+/**
+ * Default logger instance
+ */
+export const defaultLogger = createLogger('SubWallet');
+
+// Export types
+
+// Export Logger class for advanced usage
+export { Logger } from "./Logger.js";
+
+// Export Sentry adapter for future integration
+// export { sentryAdapter } from './sentry-adapter';

package/utils/logger/types.d.ts

@@ -0,0 +1,23 @@
+export declare type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export interface LoggerConfig {
+    name: string;
+    level?: LogLevel;
+    enableStructuredLogging?: boolean;
+    enableContextCapture?: boolean;
+}
+export interface LogContext {
+    file?: string;
+    function?: string;
+    line?: number;
+    column?: number;
+    timestamp: string;
+    level: LogLevel;
+    loggerName: string;
+}
+export interface StructuredLogData {
+    message: string;
+    context?: Record<string, unknown>;
+    error?: Error | unknown;
+    tags?: string[];
+    extra?: Record<string, unknown>;
+}

package/utils/logger/types.js

@@ -0,0 +1 @@
+export {};