@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/lib/api/solana/api/solanaGetPublicKey.d.ts

@@ -0,0 +1,32 @@
+import type { PROTO, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class SolanaGetPublicKey extends AbstractMethod<'solanaGetPublicKey', PROTO.SolanaGetPublicKey[]> {
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'solanaGetPublicKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<({
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } & {
+    publicKey: string;
+    publicKeyBase58: string;
+  }) | ({
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } & {
+    publicKey: string;
+    publicKeyBase58: string;
+  })[]>;
+}

package/lib/api/solana/api/solanaGetPublicKey.js

@@ -0,0 +1,86 @@
+import { base58 } from "@scure/base";
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class SolanaGetPublicKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 2);
+      return {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Solana'];
+    this.requiredFirmwareCoins = [getMiscNetwork('sol')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export Solana public key';
+  }
+  get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-xpub',
+        label: 'Export multiple Solana public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    const addressN = first.address_n;
+    const accountIndex = addressN[2];
+    return {
+      view: 'export-xpub',
+      label: `Export Solana public key for account #${fromHardenedPathPart(accountIndex) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      const {
+        message
+      } = await cmd.typedCall('SolanaGetPublicKey', 'SolanaPublicKey', batch);
+      const publicKeyBase58 = base58.encode(Buffer.from(message.public_key, 'hex'));
+      responses.push({
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.public_key,
+        publicKeyBase58,
+        displayablePublicKey: publicKeyBase58
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/solana/api/solanaSignTransaction.d.ts

@@ -0,0 +1,41 @@
+import type { PROTO, PermissionRequest, TokenInfo } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.SolanaSignTx;
+  serialize: boolean;
+  symbols?: (string | undefined)[];
+};
+export default class SolanaSignTransaction extends AbstractMethod<'solanaSignTransaction', Params> {
+  constructor(message: MethodMessage<'solanaSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  payloadToPrecomposed(): Promise<{
+    type: "final";
+    inputs: never[];
+    outputsPermutation: number[];
+    outputs: {
+      address: string;
+      amount: string;
+      script_type: "PAYTOADDRESS";
+    }[];
+    totalSpent: string;
+    fee: string;
+    feePerByte: string;
+    feeLimit: string;
+    bytes: number;
+    max: undefined;
+    isTokenKnown: boolean;
+    token: TokenInfo | undefined;
+    createdTimestamp: number | undefined;
+  } | undefined>;
+  run(): Promise<{
+    signature: string;
+    serializedTx: string;
+  } | {
+    signature: string;
+    serializedTx?: undefined;
+  }>;
+}
+export {};

package/lib/api/solana/api/solanaSignTransaction.js

@@ -0,0 +1,204 @@
+import { SolanaSignTransaction as SolanaSignTransactionSchema, SolanaTxAdditionalInfo } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import solana from "@trezor/network-solana/runtime";
+import { Assert } from "@trezor/schema-utils";
+import { BigNumber } from "@trezor/utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
+import { getSolanaTokenDefinition } from "../solanaDefinitions.js";
+export default class SolanaSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(SolanaSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 2);
+    let additional_info;
+    let symbols;
+    if (payload.additionalInfo) {
+      Assert(SolanaTxAdditionalInfo, payload.additionalInfo);
+      const token_accounts_infos = payload.additionalInfo.tokenAccountsInfos?.map(tokenAccountInfo => ({
+        base_address: tokenAccountInfo.baseAddress,
+        token_program: tokenAccountInfo.tokenProgram,
+        token_mint: tokenAccountInfo.tokenMint,
+        token_account: tokenAccountInfo.tokenAccount
+      })) ?? [];
+      symbols = payload.additionalInfo.tokenAccountsInfos?.map(tokenAccountInfo => tokenAccountInfo.symbol) ?? [];
+      additional_info = {
+        token_accounts_infos
+      };
+    }
+    const proto = {
+      address_n: path,
+      serialized_tx: payload.serializedTx,
+      additional_info,
+      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined,
+      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false
+    };
+    const params = {
+      proto,
+      serialize: !!payload.serialize,
+      symbols
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Solana'];
+    this.requiredFirmwareCoins = [getMiscNetwork('sol')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  async initAsync() {
+    const token = this.params.proto.additional_info?.token_accounts_infos?.[0];
+    if (token) {
+      const tokenDefinition = await getSolanaTokenDefinition({
+        mintAddress: token.token_mint
+      });
+      if (!tokenDefinition) return;
+      this.params.proto.additional_info.encoded_token = tokenDefinition;
+    }
+  }
+  get info() {
+    return 'Sign Solana transaction';
+  }
+  async payloadToPrecomposed() {
+    try {
+      const {
+        getDecompiledMessage
+      } = await solana();
+      const {
+        message,
+        baseFee,
+        instructions
+      } = getDecompiledMessage(this.params.proto.serialized_tx, this.params.serialize);
+      const outputs = [];
+      let feePerUnit = new BigNumber(0);
+      let feeLimit = new BigNumber(0);
+      let rent = new BigNumber(0);
+      let sendAmount = new BigNumber(0);
+      let token;
+      for (const instruction of instructions) {
+        const {
+          type,
+          parsed
+        } = instruction;
+        switch (type) {
+          case 'unit-price':
+            {
+              feePerUnit = new BigNumber(parsed.data.microLamports.toString());
+              break;
+            }
+          case 'unit-limit':
+            {
+              feeLimit = new BigNumber(parsed.data.units.toString());
+              break;
+            }
+          case 'transfer-sol':
+            {
+              outputs.push({
+                address: parsed.accounts.destination.address,
+                amount: parsed.data.amount.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              sendAmount = sendAmount.plus(parsed.data.amount.toString());
+              break;
+            }
+          case 'create-account':
+            {
+              outputs.push({
+                address: parsed.accounts.newAccount.address,
+                amount: parsed.data.lamports.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              rent = rent.plus(parsed.data.lamports.toString());
+              break;
+            }
+          case 'transfer-checked':
+            {
+              const destinationATA = parsed.accounts.destination.address;
+              const tokenAccountInfos = this.params.proto.additional_info?.token_accounts_infos ?? [];
+              const tokenInfoIndex = tokenAccountInfos.findIndex(t => t.token_account === destinationATA && t.token_mint === parsed.accounts.mint.address);
+              const tokenInfo = tokenAccountInfos[tokenInfoIndex];
+              if (!sendAmount.isZero()) {
+                throw ERRORS.TypedError('Runtime', 'Multiple token transfers in a single transaction are not supported');
+              }
+              outputs.push({
+                address: tokenInfo?.base_address || destinationATA,
+                amount: parsed.data.amount.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              sendAmount = new BigNumber(parsed.data.amount.toString());
+              token = {
+                standard: 'SPL',
+                contract: parsed.accounts.mint.address,
+                decimals: parsed.data.decimals,
+                symbol: this.params.symbols?.[tokenInfoIndex]
+              };
+              break;
+            }
+          case 'other':
+          default:
+            break;
+        }
+      }
+      if (outputs.length === 0) {
+        throw ERRORS.TypedError('Runtime', 'No outputs decoded');
+      }
+      const fee = baseFee.plus(feePerUnit.multipliedBy(feeLimit).dividedBy(1e6));
+      const totalSpent = sendAmount.plus(rent).plus(fee);
+      return {
+        type: 'final',
+        inputs: [],
+        outputsPermutation: [0],
+        outputs,
+        totalSpent: token ? sendAmount.toString() : totalSpent.toString(),
+        fee: fee.toString(),
+        feePerByte: feePerUnit.toString(),
+        feeLimit: feeLimit.toString(),
+        bytes: 0,
+        max: undefined,
+        isTokenKnown: false,
+        token,
+        createdTimestamp: 'blockhash' in message.lifetimeConstraint ? new Date().getTime() : undefined
+      };
+    } catch (e) {
+      console.error('Error in payloadToPrecomposed', e);
+    }
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    if (this.params.serialize) {
+      const {
+        createTransactionShimFromHex
+      } = await solana();
+      const tx = createTransactionShimFromHex(this.params.proto.serialized_tx);
+      const addressCall = await cmd.typedCall('SolanaGetAddress', 'SolanaAddress', {
+        address_n: this.params.proto.address_n,
+        show_display: false,
+        chunkify: false
+      });
+      const {
+        address
+      } = addressCall.message;
+      const {
+        message
+      } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', {
+        ...this.params.proto,
+        serialized_tx: tx.serializeMessage()
+      });
+      tx.addSignature(address, message.signature);
+      const signedSerializedTx = tx.serialize();
+      return {
+        signature: message.signature,
+        serializedTx: signedSerializedTx
+      };
+    }
+    const {
+      message
+    } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', this.params.proto);
+    return {
+      signature: message.signature
+    };
+  }
+}

package/lib/api/solana/solanaDefinitions.d.ts

@@ -0,0 +1,9 @@
+import { MessagesSchema } from '@trezor/protobuf';
+interface GetSolanaTokenDefinition {
+  mintAddress?: string;
+}
+export declare const getSolanaTokenDefinition: ({
+  mintAddress
+}: GetSolanaTokenDefinition) => Promise<ArrayBuffer | undefined>;
+export declare const decodeSolanaTokenDefinition: (encodedDefinition: ArrayBuffer) => MessagesSchema.SolanaTokenInfo;
+export {};

package/lib/api/solana/solanaDefinitions.js

@@ -0,0 +1,33 @@
+import fetch from "cross-fetch";
+import { MessagesSchema, protobufManager } from "@trezor/protobuf";
+import { trzd } from "@trezor/protocol";
+import { Assert } from "@trezor/schema-utils";
+export const getSolanaTokenDefinition = async ({
+  mintAddress
+}) => {
+  try {
+    if (mintAddress) {
+      const tokenDefinitionUrl = `https://data.trezor.io/firmware/definitions/solana/token/${mintAddress}.dat`;
+      const tokenDefinition = await fetch(tokenDefinitionUrl);
+      if (tokenDefinition.status === 200) {
+        const arrayBuffer = await tokenDefinition.arrayBuffer();
+        return arrayBuffer;
+      } else if (tokenDefinition.status !== 404) {
+        throw new Error(`unexpected status: ${tokenDefinition.status}`);
+      }
+    }
+  } catch (err) {
+    console.warn(`unable to download or parse solana token ${mintAddress} definition. detail: ${err.message}`);
+  }
+  return undefined;
+};
+export const decodeSolanaTokenDefinition = encodedDefinition => {
+  const {
+    protobufPayload
+  } = trzd.decode(encodedDefinition);
+  const {
+    message: decodedTokenDefinition
+  } = protobufManager.decode('SolanaTokenInfo', protobufPayload);
+  Assert(MessagesSchema.SolanaTokenInfo, decodedTokenDefinition);
+  return decodedTokenDefinition;
+};

package/lib/api/stellar/api/index.d.ts

@@ -0,0 +1,2 @@
+export { default as stellarGetAddress } from "./stellarGetAddress.js";
+export { default as stellarSignTransaction } from "./stellarSignTransaction.js";

package/lib/api/stellar/api/index.js

@@ -0,0 +1,2 @@
+export { default as stellarGetAddress } from "./stellarGetAddress.js";
+export { default as stellarSignTransaction } from "./stellarSignTransaction.js";

package/lib/api/stellar/api/stellarGetAddress.d.ts

@@ -0,0 +1,17 @@
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+import type { MiscGetAddressParams } from "../../common/AbstractMiscGetAddress.js";
+export default class StellarGetAddress extends AbstractMiscGetAddress<'stellarGetAddress'> {
+  constructor(message: MethodMessage<'stellarGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/stellar/api/stellarGetAddress.js

@@ -0,0 +1,22 @@
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+export default class StellarGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 3);
+    this.requiredDeviceCapabilities = ['Capability_Stellar'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xlm')];
+  }
+  get info() {
+    return this.getInfo('Stellar', true);
+  }
+  get confirmation() {
+    return this.getConfirmation('Stellar');
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('StellarGetAddress', 'StellarAddress', proto);
+    return response.message;
+  }
+}

package/lib/api/stellar/api/stellarSignTransaction.d.ts

@@ -0,0 +1,20 @@
+import { StellarSignTransaction as StellarSignTransactionSchema } from '@trezor/connect-common';
+import type { PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  path: number[];
+} & StellarSignTransactionSchema;
+export default class StellarSignTransaction extends AbstractMethod<'stellarSignTransaction', Params> {
+  constructor(message: MethodMessage<'stellarSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  private _isFeatureSupported;
+  private _ensureFirmwareSupportsOperation;
+  private parseFromXdr;
+  run(): Promise<{
+    publicKey: string;
+    signature: string;
+  }>;
+}
+export {};

package/lib/api/stellar/api/stellarSignTransaction.js

@@ -0,0 +1,65 @@
+import { StellarSignTransaction as StellarSignTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import stellar from "@trezor/network-stellar/runtime";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
+import * as helper from "../stellarSignTx.js";
+const StellarSignTransactionFeatures = Object.freeze({
+  manageBuyOffer: ['1.10.4', '2.4.3'],
+  pathPaymentStrictSend: ['1.10.4', '2.4.3']
+});
+export default class StellarSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(StellarSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const {
+      payment_req
+    } = payload;
+    const params = {
+      ...payload,
+      path,
+      payment_req: payment_req ? encodePaymentRequestAmount(payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Stellar'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xlm')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Sign Stellar transaction';
+  }
+  _isFeatureSupported(feature) {
+    return this.getDevice().atLeast(StellarSignTransactionFeatures[feature]);
+  }
+  _ensureFirmwareSupportsOperation(feature, operations = []) {
+    if (operations.find(o => o.type === feature) && !this._isFeatureSupported(feature)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
+    }
+  }
+  async parseFromXdr(xdrBase64, testnet) {
+    const {
+      parseTransactionFromXDR,
+      transformTransaction
+    } = await stellar();
+    const nativeTx = parseTransactionFromXDR(xdrBase64, testnet);
+    return [transformTransaction(nativeTx), nativeTx.networkPassphrase];
+  }
+  async run() {
+    const [transaction, networkPassphrase] = 'xdrBase64' in this.params ? await this.parseFromXdr(this.params.xdrBase64, this.params.testnet) : [this.params.transaction, this.params.networkPassphrase];
+    this._ensureFirmwareSupportsOperation('manageBuyOffer', transaction.operations);
+    this._ensureFirmwareSupportsOperation('pathPaymentStrictSend', transaction.operations);
+    const response = await helper.stellarSignTx(this.getDevice().getCommands().typedCall, this.params.path, networkPassphrase, transaction, this.params.payment_req);
+    return {
+      publicKey: response.public_key,
+      signature: response.signature
+    };
+  }
+}

package/lib/api/stellar/stellarSignTx.d.ts

@@ -0,0 +1,7 @@
+import type { StellarTransaction } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { TypedCall } from "../../device/DeviceCommands.js";
+export declare const stellarSignTx: (typedCall: TypedCall, address_n: number[], network_passphrase: string, tx: StellarTransaction, payment_req?: PROTO.PaymentRequest) => Promise<{
+  public_key: string;
+  signature: string;
+}>;