@aeternity/aepp-sdk 13.0.1 → 13.2.0

package/src/account/Rpc.ts

@@ -4,6 +4,7 @@ import { ArgumentError, NotImplementedError, UnsupportedProtocolError } from '..
 import { Encoded } from '../utils/encoder';
 import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
 import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
+import { AensName } from '../tx/builder/constants';
 
 /**
  * Account provided by wallet
@@ -28,20 +29,17 @@ export default class AccountRpc extends AccountBase {
     throw new NotImplementedError('RAW signing using wallet');
   }
 
-  /**
-   * @returns Signed transaction
-   */
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},
   ): Promise<Encoded.Transaction> {
-    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');
     if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
     const res = await this._rpcClient.request(METHODS.sign, {
       onAccount: this.address,
       tx,
       returnSigned: true,
       networkId,
+      innerTx,
     });
     if (res.signedTransaction == null) {
       throw new UnsupportedProtocolError('signedTransaction is missed in wallet response');
@@ -49,12 +47,61 @@ export default class AccountRpc extends AccountBase {
     return res.signedTransaction;
   }
 
-  /**
-   * @returns Signed message
-   */
   override async signMessage(message: string): Promise<Uint8Array> {
     const { signature } = await this._rpcClient
       .request(METHODS.signMessage, { onAccount: this.address, message });
     return Buffer.from(signature, 'hex');
   }
+
+  override async signTypedData(
+    data: Encoded.ContractBytearray,
+    aci: Parameters<AccountBase['signTypedData']>[1],
+    {
+      name, version, contractAddress, networkId,
+    }: Parameters<AccountBase['signTypedData']>[2] = {},
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signTypedData, {
+      onAccount: this.address,
+      domain: {
+        name, version, networkId, contractAddress,
+      },
+      aci,
+      data,
+    });
+    return signature;
+  }
+
+  override async signDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+    });
+    return signature;
+  }
+
+  override async signNameDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+      name,
+    });
+    return signature;
+  }
+
+  override async signOracleQueryDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+      oracleQueryId,
+    });
+    return signature;
+  }
 }

package/src/aens.ts

@@ -379,7 +379,7 @@ interface AensPreclaimOptions extends
  * @example
  * ```js
  * const name = 'test.chain'
- * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ * const bidFee = computeBidFee(name, { startFee, increment: 0.42 })
  *
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  * ```

package/src/aepp-wallet-communication/rpc/RpcClient.ts

@@ -1,6 +1,7 @@
 import { RpcError, RpcInternalError, RpcMethodNotFoundError } from '../schema';
 import BrowserConnection from '../connection/Browser';
 import { InvalidRpcMessageError, MissingCallbackError } from '../../utils/errors';
+import { ensureError } from '../../utils/other';
 
 interface JsonRpcRequest {
   jsonrpc: '2.0';
@@ -64,17 +65,24 @@ export default class RpcClient <
 
     const request = msg as JsonRpcRequest;
     let result;
-    let error;
+    let error: Error | undefined;
     try {
       if (!(request.method in this.#methods)) throw new RpcMethodNotFoundError();
       const methodName = request.method as keyof LocalApi;
       result = await this.#methods[methodName](request.params, origin);
     } catch (e) {
-      error = e instanceof RpcError ? e : new RpcInternalError();
+      ensureError(e);
+      error = e;
     }
     if (request.id != null) {
-      this.#sendResponse(request.id, request.method as keyof LocalApi, result, error);
+      this.#sendResponse(
+        request.id,
+        request.method as keyof LocalApi,
+        result,
+        error == null || error instanceof RpcError ? error : new RpcInternalError(),
+      );
     }
+    if (error != null && !(error instanceof RpcError)) throw error;
   }
 
   #sendRequest(

package/src/aepp-wallet-communication/rpc/types.ts

@@ -1,7 +1,9 @@
 import { Encoded } from '../../utils/encoder';
+import { Domain, AciValue } from '../../utils/typed-data';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
 import { TransformNodeType } from '../../Node';
 import { SignedTx } from '../../apis/node';
+import { AensName } from '../../tx/builder/constants';
 
 export interface WalletInfo {
   id: string;
@@ -55,6 +57,7 @@ export interface WalletApi {
        * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
        */
       networkId: string;
+      innerTx?: boolean;
     }
   ) => Promise<{
     /**
@@ -71,6 +74,24 @@ export interface WalletApi {
   [METHODS.signMessage]: (
     p: { message: string; onAccount: Encoded.AccountAddress }
   ) => Promise<{ signature: string }>;
+
+  [METHODS.signTypedData]: (
+    p: {
+      domain: Domain;
+      aci: AciValue;
+      data: Encoded.ContractBytearray;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
+
+  [METHODS.signDelegationToContract]: (
+    p: {
+      contractAddress: Encoded.ContractAddress;
+      name?: AensName;
+      oracleQueryId?: Encoded.OracleQueryId;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
 }
 
 export interface AeppApi {

package/src/aepp-wallet-communication/schema.ts

@@ -36,6 +36,8 @@ export const enum METHODS {
   connect = 'connection.open',
   sign = 'transaction.sign',
   signMessage = 'message.sign',
+  signTypedData = 'typedData.sign',
+  signDelegationToContract = 'delegationToContract.sign',
   subscribeAddress = 'address.subscribe',
   updateNetwork = 'networkId.update',
   closeConnection = 'connection.close',
@@ -64,7 +66,7 @@ const rpcErrors: Array<(new (data?: any) => RpcError) & { code: number }> = [];
 export abstract class RpcError extends BaseError {
   static code: number;
 
-  code: number;
+  code!: number;
 
   data?: any;
 
@@ -99,22 +101,6 @@ export class RpcInvalidTransactionError extends RpcError {
 }
 rpcErrors.push(RpcInvalidTransactionError);
 
-/**
- * @category exception
- */
-export class RpcBroadcastError extends RpcError {
-  static override code = 3;
-
-  override code = 3;
-
-  constructor(data?: any) {
-    super('Broadcast failed');
-    this.data = data;
-    this.name = 'RpcBroadcastError';
-  }
-}
-rpcErrors.push(RpcBroadcastError);
-
 /**
  * @category exception
  */

package/src/aepp-wallet-communication/wallet-detector.ts

@@ -22,7 +22,7 @@ interface Wallets { [key: string]: Wallet }
  */
 export default (
   connection: BrowserConnection,
-  onDetected: ({ wallets, newWallet }: { wallets: Wallets; newWallet?: Wallet }) => void,
+  onDetected: ({ wallets, newWallet }: { wallets: Wallets; newWallet: Wallet }) => void,
 ): () => void => {
   if (window == null) throw new UnsupportedPlatformError('Window object not found, you can run wallet detector only in browser');
   const wallets: Wallets = {};
@@ -49,7 +49,6 @@ export default (
     wallets[wallet.info.id] = wallet;
     onDetected({ wallets, newWallet: wallet });
   }, () => {});
-  if (Object.keys(wallets).length > 0) onDetected({ wallets });
 
   return () => connection.disconnect();
 };

package/src/apis/compiler/compiler.ts

@@ -260,7 +260,14 @@ const generateACIOperationSpec: coreClient.OperationSpec = {
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.Aci
+      bodyMapper: {
+        type: {
+          name: "Sequence",
+          element: {
+            type: { name: "Dictionary", value: { type: { name: "any" } } }
+          }
+        }
+      }
     },
     400: {
       bodyMapper: {

package/src/apis/compiler/models/index.ts

@@ -12,13 +12,6 @@ export interface CompileOpts {
   srcFile?: string;
 }
 
-export interface Aci {
-  /** Any object */
-  encodedAci: Record<string, unknown>;
-  externalEncodedAci?: Record<string, unknown>[];
-  interface: string;
-}
-
 export interface CompilerError {
   type: string;
   pos: ErrorPos;
@@ -151,7 +144,7 @@ export interface GenerateACIOptionalParams
   extends coreClient.OperationOptions {}
 
 /** Contains response data for the generateACI operation. */
-export type GenerateACIResponse = Aci;
+export type GenerateACIResponse = Record<string, unknown>[];
 
 /** Optional parameters. */
 export interface CompileContractOptionalParams

package/src/apis/compiler/models/mappers.ts

@@ -45,42 +45,6 @@ export const CompileOpts: coreClient.CompositeMapper = {
   }
 };
 
-export const Aci: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "Aci",
-    modelProperties: {
-      encodedAci: {
-        serializedName: "encoded_aci",
-        required: true,
-        type: {
-          name: "Dictionary",
-          value: { type: { name: "any" } }
-        }
-      },
-      externalEncodedAci: {
-        serializedName: "external_encoded_aci",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Dictionary",
-              value: { type: { name: "any" } }
-            }
-          }
-        }
-      },
-      interface: {
-        serializedName: "interface",
-        required: true,
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
 export const CompilerError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",

package/src/apis/middleware/index.ts

@@ -0,0 +1,2 @@
+export * from "./models";
+export { Middleware } from "./middleware";