@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.0

package/types-legacy/ts4.2/account/Rpc.d.ts

@@ -0,0 +1,25 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
+import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
+/**
+ * Account provided by wallet
+ * @param params - Params
+ * @param params.rpcClient - RpcClient instance
+ * @param params.address - RPC account address
+ * @returns AccountRpc instance
+ */
+export default class AccountRpc extends AccountBase {
+    _rpcClient: RpcClient<WalletApi, AeppApi>;
+    readonly address: Encoded.AccountAddress;
+    constructor(rpcClient: RpcClient<WalletApi, AeppApi>, address: Encoded.AccountAddress);
+    sign(): Promise<Uint8Array>;
+    /**
+     * @returns Signed transaction
+     */
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    /**
+     * @returns Signed message
+     */
+    signMessage(message: string): Promise<Uint8Array>;
+}

package/types-legacy/ts4.2/aens.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Aens methods - routines to interact with the æternity naming system
+ *
+ * The high-level description of the naming system is
+ * https://github.com/aeternity/protocol/blob/master/AENS.md in the protocol
+ * repository.
+ */
+import BigNumber from 'bignumber.js';
+import { Tag, AensName } from './tx/builder/constants';
+import { Encoded } from './utils/encoder';
+import { send, SendOptions } from './spend';
+import { getName } from './chain';
+import { BuildTxOptions } from './tx';
+import { TransformNodeType } from './Node';
+import { NameEntry, NamePointer } from './apis/node';
+import AccountBase from './account/Base';
+import { AddressEncodings } from './tx/builder/field-types/address';
+interface KeyPointers {
+    [key: string]: Encoded.Generic<AddressEncodings>;
+}
+/**
+ * Revoke a name
+ * @category AENS
+ * @param name - Name hash
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensRevoke(name, { fee, ttl , nonce })
+ * // or
+ * await nameObject.revoke({ fee, ttl, nonce })
+ * ```
+ */
+export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof send>;
+interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId'>, SendOptions {
+}
+/**
+ * Update a name
+ * @category AENS
+ * @param name - AENS name
+ * @param pointers - Map of pointer keys to corresponding addresses
+ * @param options - Options
+ * @param options.extendPointers - Get the pointers from the node and merge with provided
+ * ones. Pointers with the same type will be overwritten
+ * @param options.onAccount - Make operation on specific account from sdk (you
+ * pass publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameTtl - Name ttl represented in number of
+ * blocks (Max value is 50000 blocks)
+ * @param options.clientTtl=84600 a suggestion as to how long any
+ * clients should cache this information
+ * @throws Invalid pointer array error
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const pointersArray = ['ak_asd23dasdas...,' 'ct_asdf34fasdasd...']
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensUpdate(name, pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
+ * // or
+ * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
+ * ```
+ */
+export declare function aensUpdate(name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions): ReturnType<typeof send>;
+interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>, SendOptions {
+    extendPointers?: boolean;
+    clientTtl?: number;
+    nameTtl?: number;
+}
+/**
+ * Transfer a domain to another account
+ * @category AENS
+ * @param name - AENS name
+ * @param account - Recipient account publick key
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const recipientPub = 'ak_asd23dasdas...'
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensTransfer(name, recipientPub, { ttl, fee, nonce })
+ * // or
+ * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
+ * ```
+ */
+export declare function aensTransfer(name: AensName, account: Encoded.AccountAddress, options: AensTransferOptions): ReturnType<typeof send>;
+interface AensTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId'>, SendOptions {
+}
+/**
+ * Query the AENS name info from the node
+ * and return the object with info and predefined functions for manipulating name
+ * @category AENS
+ * @param name - AENS name
+ * @param opt - Options
+ * @returns
+ * @example
+ * ```js
+ * const nameObject = sdkInstance.aensQuery('test.chain')
+ * console.log(nameObject)
+ * {
+ *  id, // name hash
+ *  pointers, // array of pointers
+ *  update, // Update name function
+ *  extendTtl, // Extend Ttl name function
+ *  transfer, // Transfer name function
+ *  revoke // Revoke name function
+ * }
+ * ```
+ */
+export declare function aensQuery(name: AensName, opt: Parameters<typeof getName>[1] & Parameters<typeof aensUpdate>[2] & Parameters<typeof aensTransfer>[2]): Promise<Readonly<TransformNodeType<NameEntry> & {
+    id: Encoded.Name;
+    owner: Encoded.AccountAddress;
+    pointers: KeyPointers | NamePointer[];
+    ttl: number;
+    update: (pointers: KeyPointers, options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+        onAccount?: AccountBase;
+    }) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
+    transfer: (account: Encoded.AccountAddress, options?: Parameters<typeof aensQuery>[1]) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
+    revoke: (options?: Omit<Parameters<typeof aensRevoke>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+        onAccount?: AccountBase;
+    }) => ReturnType<typeof aensRevoke>;
+    extendTtl: (nameTtl: number, options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'>) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
+}>>;
+/**
+ * Claim a previously preclaimed registration. This can only be done after the
+ * preclaim step
+ * @category AENS
+ * @param name - AENS name
+ * @param salt - Salt from pre-claim, or 0 if it's a bid
+ * @param options - options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameFee - Name Fee (By default calculated by sdk)
+ * @returns the result of the claim
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const salt = preclaimResult.salt // salt from pre-claim transaction
+ *
+ * await sdkInstance.aensClaim(name, salt, { ttl, fee, nonce, nameFee })
+ * ```
+ */
+export declare function aensClaim(name: AensName, salt: number, options: AensClaimOptions): Promise<AensClaimReturnType>;
+type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendOptions & Parameters<typeof aensQuery>[1];
+interface AensClaimOptions extends AensClaimOptionsType {
+}
+interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
+}
+/**
+ * Preclaim a name. Sends a hash of the name and a random salt to the node
+ * @category AENS
+ * @param name - AENS name
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const salt = preclaimResult.salt // salt from pre-claim transaction
+ *
+ * await sdkInstance.aensPreclaim(name, { ttl, fee, nonce })
+ * {
+ *   ...transactionResult,
+ *   claim, // Claim function (options={}) => claimTransactionResult
+ *   salt,
+ *   commitmentId
+ * }
+ * ```
+ */
+export declare function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<Awaited<ReturnType<typeof send>> & {
+    height: number;
+    salt: number;
+    commitmentId: string;
+    claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>;
+}>>;
+interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, AensClaimOptions {
+}
+/**
+ * Bid to name auction
+ * @category AENS
+ * @param name - Domain name
+ * @param nameFee - Name fee (bid fee)
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ *
+ * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
+ * ```
+ */
+export declare function aensBid(name: AensName, nameFee: number | string | BigNumber, options: Omit<Parameters<typeof aensClaim>[2], 'nameFee'>): ReturnType<typeof aensClaim>;
+export {};

package/types-legacy/ts4.2/aepp-wallet-communication/connection/Browser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Browser connection base interface
+ * @category aepp wallet communication
+ */
+export default abstract class BrowserConnection {
+    debug: boolean;
+    protected constructor({ debug }: {
+        debug?: boolean;
+    });
+    /**
+     * Connect
+     * @param onMessage - Message handler
+     * @param onDisconnect - trigger when runtime connection in closed
+     */
+    connect(onMessage: (message: any, origin: string, source: any) => void, onDisconnect: () => void): void;
+    /**
+     * Disconnect
+     */
+    disconnect(): void;
+    /**
+     * Receive message
+     */
+    protected receiveMessage(message: any): void;
+    /**
+     * Send message
+     */
+    sendMessage(message: any): void;
+    /**
+     * Check if connected
+     * @returns Is connected
+     */
+    abstract isConnected(): boolean;
+}

package/types-legacy/ts4.2/aepp-wallet-communication/connection/BrowserRuntime.d.ts

@@ -0,0 +1,18 @@
+import { Runtime } from 'webextension-polyfill';
+import BrowserConnection from './Browser';
+/**
+ * BrowserRuntimeConnection
+ * Handle browser runtime communication
+ * @category aepp wallet communication
+ */
+export default class BrowserRuntimeConnection extends BrowserConnection {
+    port: Runtime.Port;
+    constructor({ port, ...options }: {
+        port: Runtime.Port;
+        debug: boolean;
+    });
+    disconnect(): void;
+    connect(onMessage: (message: any, origin: string, source: Runtime.Port) => void, onDisconnect: () => void): void;
+    sendMessage(message: any): void;
+    isConnected(): boolean;
+}

package/types-legacy/ts4.2/aepp-wallet-communication/connection/BrowserWindowMessage.d.ts

@@ -0,0 +1,36 @@
+import BrowserConnection from './Browser';
+import { MESSAGE_DIRECTION } from '../schema';
+export type ImplPostMessage = Pick<Window, 'addEventListener' | 'removeEventListener' | 'postMessage'>;
+/**
+ * Browser window Post Message connector module
+ * @category aepp wallet communication
+ */
+export default class BrowserWindowMessageConnection extends BrowserConnection {
+    #private;
+    origin?: string;
+    sendDirection?: MESSAGE_DIRECTION;
+    receiveDirection: MESSAGE_DIRECTION;
+    listener?: (this: Window, ev: MessageEvent<any>) => void;
+    /**
+     * @param options - Options
+     * @param options.target Target window for message
+     * @param options.self Host window for message
+     * @param options.origin Origin of receiver
+     * @param options.sendDirection Wrapping messages into additional struct
+     * `({ type: 'to_aepp' || 'to_waellet', data })`
+     * Used for handling messages between content script and page
+     * @param options.receiveDirection Unwrapping messages from additional struct
+     */
+    constructor({ target, self, origin, sendDirection, receiveDirection, ...options }?: {
+        target?: ImplPostMessage;
+        self?: ImplPostMessage;
+        origin?: string;
+        sendDirection?: MESSAGE_DIRECTION;
+        receiveDirection?: MESSAGE_DIRECTION;
+        debug?: boolean;
+    });
+    isConnected(): boolean;
+    connect(onMessage: (message: any, origin: string, source: MessageEventSource | null) => void, onDisconnect: () => void): void;
+    disconnect(): void;
+    sendMessage(msg: any): void;
+}

package/types-legacy/ts4.2/aepp-wallet-communication/connection-proxy.d.ts

@@ -0,0 +1,11 @@
+import BrowserConnection from './connection/Browser';
+/**
+ * Browser connection proxy
+ * Provide functionality to easily forward messages from one connection to another and back
+ * @category aepp wallet communication
+ * @param con1 - first connection
+ * @param con2 - second connection
+ * @returns a function to stop proxying
+ */
+declare const _default: (con1: BrowserConnection, con2: BrowserConnection) => () => void;
+export default _default;

package/types-legacy/ts4.2/aepp-wallet-communication/rpc/RpcClient.d.ts

@@ -0,0 +1,34 @@
+import BrowserConnection from '../connection/Browser';
+type RpcApiHandler = (p?: any) => any | undefined;
+type RpcApi<Api> = {
+    [k in keyof Api]: RpcApiHandler;
+};
+type WithOrigin<Api extends RpcApi<Api>> = {
+    [k in keyof Api]: (p: Parameters<Api[k]>[0], origin: string) => ReturnType<Api[k]>;
+};
+/**
+ * Contain functionality for using RPC conection
+ * @category aepp wallet communication
+ * @param connection - Connection object
+ * @param onDisconnect - Disconnect callback
+ * @param methods - Object containing handlers for each request by name
+ */
+export default class RpcClient<RemoteApi extends RpcApi<RemoteApi>, LocalApi extends RpcApi<LocalApi>> {
+    #private;
+    connection: BrowserConnection;
+    constructor(connection: BrowserConnection, onDisconnect: () => void, methods: WithOrigin<LocalApi>);
+    /**
+     * Make a request
+     * @param name - Method name
+     * @param params - Method params
+     * @returns Promise which will be resolved after receiving response message
+     */
+    request<Name extends keyof RemoteApi>(name: Name, params: Parameters<RemoteApi[Name]>[0]): Promise<ReturnType<RemoteApi[Name]>>;
+    /**
+     * Make a notification
+     * @param name - Method name
+     * @param params - Method params
+     */
+    notify<Name extends keyof RemoteApi>(name: Name, params: Parameters<RemoteApi[Name]>[0]): void;
+}
+export {};

package/types-legacy/ts4.2/aepp-wallet-communication/rpc/types.d.ts

@@ -0,0 +1,83 @@
+import { send } from '../../spend';
+import { Encoded } from '../../utils/encoder';
+import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
+export interface WalletInfo {
+    id: string;
+    name: string;
+    networkId: string;
+    origin: string;
+    type: WALLET_TYPE;
+}
+export interface Accounts {
+    connected: {
+        [pub: string]: {};
+    };
+    current: {
+        [pub: string]: {};
+    };
+}
+export interface Node {
+    name: string;
+    url: string;
+}
+export interface Network {
+    networkId: string;
+    node?: Node;
+}
+type Icons = Array<{
+    src: string;
+    sizes?: string;
+    type?: string;
+    purpose?: string;
+}>;
+export declare const RPC_VERSION = 1;
+export interface WalletApi {
+    [METHODS.connect]: (p: {
+        name: string;
+        icons?: Icons;
+        version: typeof RPC_VERSION;
+        connectNode: boolean;
+    }) => Promise<WalletInfo & {
+        node?: Node;
+    }>;
+    [METHODS.closeConnection]: (p: any) => void;
+    [METHODS.subscribeAddress]: (p: {
+        type: SUBSCRIPTION_TYPES;
+        value: 'connected' | 'current';
+    }) => Promise<{
+        subscription: Array<'connected' | 'current'>;
+        address: Accounts;
+    }>;
+    [METHODS.address]: () => Promise<Encoded.AccountAddress[]>;
+    [METHODS.sign]: ((p: {
+        tx: Encoded.Transaction;
+        onAccount: Encoded.AccountAddress;
+        returnSigned: boolean;
+        /**
+         * @deprecated Wallet provided networkId will be used (current network)
+         * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
+         * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
+         */
+        networkId: string;
+    }) => Promise<{
+        /**
+         * @deprecated this is not a hash at all, will be removed later at the same time
+         * as dropping ability to broadcast transaction by wallet
+         */
+        transactionHash?: Awaited<ReturnType<typeof send>>;
+        signedTransaction?: Encoded.Transaction;
+    }>);
+    [METHODS.signMessage]: (p: {
+        message: string;
+        onAccount: Encoded.AccountAddress;
+    }) => Promise<{
+        signature: string;
+    }>;
+}
+export interface AeppApi {
+    [METHODS.updateAddress]: (a: Accounts) => void;
+    [METHODS.updateNetwork]: (a: Network) => void;
+    [METHODS.readyToConnect]: (w: WalletInfo) => void;
+    [METHODS.closeConnection]: (p: any) => void;
+}
+export {};

package/types-legacy/ts4.2/aepp-wallet-communication/schema.d.ts

@@ -0,0 +1,133 @@
+import { Encoded } from '../utils/encoder';
+import { BaseError } from '../utils/errors';
+/**
+ * @category aepp wallet communication
+ */
+export declare const enum MESSAGE_DIRECTION {
+    to_waellet = "to_waellet",
+    to_aepp = "to_aepp"
+}
+/**
+ * @category aepp wallet communication
+ */
+export declare const enum WALLET_TYPE {
+    window = "window",
+    extension = "extension"
+}
+/**
+ * @category aepp wallet communication
+ */
+export declare const enum SUBSCRIPTION_TYPES {
+    subscribe = "subscribe",
+    unsubscribe = "unsubscribe"
+}
+/**
+ * @category aepp wallet communication
+ */
+export declare const enum METHODS {
+    readyToConnect = "connection.announcePresence",
+    updateAddress = "address.update",
+    address = "address.get",
+    connect = "connection.open",
+    sign = "transaction.sign",
+    signMessage = "message.sign",
+    subscribeAddress = "address.subscribe",
+    updateNetwork = "networkId.update",
+    closeConnection = "connection.close"
+}
+/**
+ * @category aepp wallet communication
+ */
+export declare const enum RPC_STATUS {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    WAITING_FOR_CONNECTION_REQUEST = "WAITING_FOR_CONNECTION_REQUEST"
+}
+interface RpcErrorAsJson {
+    code: number;
+    message: string;
+    data?: any;
+}
+/**
+ * @category exception
+ */
+export declare abstract class RpcError extends BaseError {
+    static code: number;
+    code: number;
+    data?: any;
+    toJSON(): RpcErrorAsJson;
+    static deserialize(json: RpcErrorAsJson): RpcError;
+}
+/**
+ * @category exception
+ */
+export declare class RpcInvalidTransactionError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcBroadcastError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcRejectedByUserError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcUnsupportedProtocolError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcConnectionDenyError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @category exception
+ */
+export declare class RpcNotAuthorizeError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcPermissionDenyError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(address: Encoded.AccountAddress);
+}
+/**
+ * @category exception
+ */
+export declare class RpcInternalError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RpcMethodNotFoundError extends RpcError {
+    static code: number;
+    code: number;
+    constructor();
+}
+export {};

package/types-legacy/ts4.2/aepp-wallet-communication/wallet-detector.d.ts

@@ -0,0 +1,25 @@
+import BrowserConnection from './connection/Browser';
+import BrowserWindowMessageConnection from './connection/BrowserWindowMessage';
+interface Wallet {
+    info: {
+        id: string;
+        type: string;
+        origin: string;
+    };
+    getConnection: () => BrowserWindowMessageConnection;
+}
+interface Wallets {
+    [key: string]: Wallet;
+}
+/**
+ * A function to detect available wallets
+ * @category aepp wallet communication
+ * @param connection - connection to use to detect wallets
+ * @param onDetected - call-back function which trigger on new wallet
+ * @returns a function to stop scanning
+ */
+declare const _default: (connection: BrowserConnection, onDetected: ({ wallets, newWallet }: {
+    wallets: Wallets;
+    newWallet?: Wallet | undefined;
+}) => void) => () => void;
+export default _default;