@firmachain/firma-js 0.2.64 → 0.3.0-beta1

package/dist/sdk/firmachain/common/signing.js

@@ -20,14 +20,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from) {
         to[j] = from[i];
     return to;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSignBytes = exports.makeSignDoc = exports.makeAuthInfoBytes = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var utils_1 = require("@cosmjs/utils");
 var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
 var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
-var long_1 = __importDefault(require("long"));
+/**
+ * Create signer infos from the provided signers.
+ *
+ * This implementation does not support different signing modes for the different signers.
+ */
 function makeSignerInfos(signers, signMode) {
     return signers.map(function (_a) {
         var pubkey = _a.pubkey, sequence = _a.sequence;
@@ -36,21 +39,30 @@ function makeSignerInfos(signers, signMode) {
             modeInfo: {
                 single: { mode: signMode },
             },
-            sequence: long_1.default.fromNumber(sequence),
+            sequence: BigInt(sequence),
         });
     });
 }
-function makeAuthInfoBytes(signers, feeAmount, gasLimit, granter, signMode) {
+/**
+ * Creates and serializes an AuthInfo document.
+ *
+ * This implementation does not support different signing modes for the different signers.
+ */
+function makeAuthInfoBytes(signers, feeAmount, gasLimit, feeGranter, feePayer, signMode) {
     if (signMode === void 0) { signMode = signing_1.SignMode.SIGN_MODE_DIRECT; }
-    var authInfo = {
+    // Required arguments 4 and 5 were added in CosmJS 0.29. Use runtime checks to help our non-TS users.
+    utils_1.assert(feeGranter === undefined || typeof feeGranter === "string", "feeGranter must be undefined or string");
+    utils_1.assert(feePayer === undefined || typeof feePayer === "string", "feePayer must be undefined or string");
+    var authInfo = tx_1.AuthInfo.fromPartial({
         signerInfos: makeSignerInfos(signers, signMode),
         fee: {
             amount: __spreadArray([], __read(feeAmount)),
-            gasLimit: long_1.default.fromNumber(gasLimit),
-            granter: granter,
+            gasLimit: BigInt(gasLimit),
+            granter: feeGranter,
+            payer: feePayer,
         },
-    };
-    return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
+    });
+    return tx_1.AuthInfo.encode(authInfo).finish();
 }
 exports.makeAuthInfoBytes = makeAuthInfoBytes;
 function makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber) {
@@ -58,7 +70,7 @@ function makeSignDoc(bodyBytes, authInfoBytes, chainId, accountNumber) {
         bodyBytes: bodyBytes,
         authInfoBytes: authInfoBytes,
         chainId: chainId,
-        accountNumber: long_1.default.fromNumber(accountNumber),
+        accountNumber: BigInt(accountNumber),
     };
 }
 exports.makeSignDoc = makeSignDoc;

package/dist/sdk/firmachain/common/signingstargateclient.d.ts

@@ -1,44 +1,121 @@
-import { EncodeObject, OfflineDirectSigner, Registry } from "@cosmjs/proto-signing";
-import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { AminoMsg, StdFee } from "@cosmjs/amino";
+import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/proto-signing";
+import { CometClient, HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import { Coin } from "cosmjs-types/cosmos/base/v1beta1/coin";
 import { SignDoc, TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import { StdFee } from ".";
-import { Account } from "./accounts";
-import { BroadcastTxResponse, StargateClient } from "./stargateclient";
+import { Height } from "cosmjs-types/ibc/core/client/v1/client";
+import { AminoConverters, AminoTypes } from "./aminotypes";
+import { GasPrice } from "./fee";
+import { DeliverTxResponse, StargateClient, StargateClientOptions } from "./stargateclient";
+export declare const defaultRegistryTypes: ReadonlyArray<[string, GeneratedType]>;
+export interface ArbitraryVerifyData {
+    type: string;
+    signer: string;
+    data: string;
+    pubkey: string;
+    signature: string;
+}
+/**
+ * Signing information for a single signer that is not included in the transaction.
+ *
+ * @see https://github.com/cosmos/cosmos-sdk/blob/v0.42.2/x/auth/signing/sign_mode_handler.go#L23-L37
+ */
 export interface SignerData {
     readonly accountNumber: number;
     readonly sequence: number;
     readonly chainId: string;
 }
-export interface SequenceResponse {
-    readonly accountNumber: number;
-    readonly sequence: number;
+/** Use for testing only */
+export interface PrivateSigningStargateClient {
+    readonly registry: Registry;
+}
+export interface SigningStargateClientOptions extends StargateClientOptions {
+    readonly registry?: Registry;
+    readonly aminoTypes?: AminoTypes;
+    readonly broadcastTimeoutMs?: number;
+    readonly broadcastPollIntervalMs?: number;
+    readonly gasPrice?: GasPrice;
 }
-export interface TxRawExt {
-    readonly txRaw: TxRaw;
-    readonly signature: string;
+export declare function createDefaultAminoConverters(): AminoConverters;
+export interface MsgSignData extends AminoMsg {
+    readonly type: "sign/MsgSignData";
+    readonly value: {
+        /** Bech32 account address */
+        signer: string;
+        /** Base64 encoded data */
+        data: string;
+    };
 }
+export declare function isMsgSignData(msg: AminoMsg): msg is MsgSignData;
 export declare class SigningStargateClient extends StargateClient {
-    private readonly signer;
-    private readonly registry;
+    readonly registry: Registry;
     private chainId;
-    private static _endpoint;
-    private getSigner;
-    static connectWithSigner(endpoint: string, signer: OfflineDirectSigner | undefined, registry: Registry): Promise<SigningStargateClient>;
-    protected constructor(tmClient: Tendermint34Client | undefined, signer: OfflineDirectSigner | undefined, registry: Registry);
-    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse>;
+    readonly broadcastTimeoutMs: number | undefined;
+    readonly broadcastPollIntervalMs: number | undefined;
+    private readonly signer;
+    private readonly aminoTypes;
+    private readonly gasPrice;
+    private readonly defaultGasMultiplier;
+    /**
+     * Creates an instance by connecting to the given CometBFT RPC endpoint.
+     *
+     * This uses auto-detection to decide between a CometBFT 0.38, Tendermint 0.37 and 0.34 client.
+     * To set the Comet client explicitly, use `createWithSigner`.
+     */
+    static connectWithSigner(endpoint: string | HttpEndpoint, signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+    /**
+     * Creates an instance from a manually created Comet client.
+     * Use this to use `Comet38Client` or `Tendermint37Client` instead of `Tendermint34Client`.
+     */
+    static createWithSigner(cometClient: CometClient, signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+    /**
+     * Creates a client in offline mode.
+     *
+     * This should only be used in niche cases where you know exactly what you're doing,
+     * e.g. when building an offline signing application.
+     *
+     * When you try to use online functionality with such a signer, an
+     * exception will be raised.
+     */
+    static offline(signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+    protected constructor(cometClient: CometClient | undefined, signer: OfflineSigner, options: SigningStargateClientOptions);
+    simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
+    sendTokens(senderAddress: string, recipientAddress: string, amount: readonly Coin[], fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
+    delegateTokens(delegatorAddress: string, validatorAddress: string, amount: Coin, fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
+    undelegateTokens(delegatorAddress: string, validatorAddress: string, amount: Coin, fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
+    withdrawRewards(delegatorAddress: string, validatorAddress: string, fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
+    /**
+     * @deprecated This API does not support setting the memo field of `MsgTransfer` (only the transaction memo).
+     * We'll remove this method at some point because trying to wrap the various message types is a losing strategy.
+     * Please migrate to `signAndBroadcast` with an `MsgTransferEncodeObject` created in the caller code instead.
+     * @see https://github.com/cosmos/cosmjs/issues/1493
+     */
+    sendIbcTokens(senderAddress: string, recipientAddress: string, transferAmount: Coin, sourcePort: string, sourceChannel: string, timeoutHeight: Height | undefined, 
+    /** timeout in seconds */
+    timeoutTimestamp: number | undefined, fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
+    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee | "auto" | number, memo?: string, timeoutHeight?: bigint): Promise<DeliverTxResponse>;
+    /**
+     * This method is useful if you want to send a transaction in broadcast,
+     * without waiting for it to be placed inside a block, because for example
+     * I would like to receive the hash to later track the transaction with another tool.
+     * @returns Returns the hash of the transaction
+     */
+    signAndBroadcastSync(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee | "auto" | number, memo?: string, timeoutHeight?: bigint): Promise<string>;
     static makeSignDocForSend(signerAddress: string, pubkeyStr: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, serverUrl: string, chainId: string, registry: Registry): Promise<SignDoc>;
-    sign(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, explicitSignerData?: SignerData): Promise<TxRaw>;
-    getChainId(): Promise<string>;
     /**
-   * Takes a bech32 encoded address and returns the data part. The prefix is ignored and discarded.
-   * This is called AccAddress in Cosmos SDK, which is basically an alias for raw binary data.
-   * The result is typically 20 bytes long but not restricted to that.
-   */
-    private static toAccAddress;
-    static getAccount(address: string): Promise<Account | undefined>;
-    static getSequence(address: string): Promise<SequenceResponse>;
-    private static makeSignerInfos;
-    private static makeAuthInfoBytes;
+     * Gets account number and sequence from the API, creates a sign doc,
+     * creates a single signature and assembles the signed transaction.
+     *
+     * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+     *
+     * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+     * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+     * (See the SigningStargateClient.offline constructor).
+     */
+    sign(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, explicitSignerData?: SignerData, timeoutHeight?: bigint): Promise<TxRaw>;
+    getChainId(): Promise<string>;
+    private signAmino;
     private signDirect;
-    signDirectForSignDoc(signerAddress: string, signDoc: SignDoc): Promise<TxRawExt>;
+    static experimentalAdr36Verify(data: ArbitraryVerifyData, checkMsg: string): Promise<boolean>;
+    experimentalAdr36Sign(signerAddress: string, data: Uint8Array | Uint8Array[]): Promise<ArbitraryVerifyData>;
 }