@ritbit/v4-client-js 2.5.2 → 2.7.0

package/build/cjs/src/clients/lib/accounts.js

@@ -5,22 +5,58 @@ const proto_signing_1 = require("@cosmjs/proto-signing");
 const stargate_1 = require("@cosmjs/stargate");
 const utils_1 = require("@cosmjs/utils");
 const auth_1 = require("cosmjs-types/cosmos/auth/v1beta1/auth");
+const minimal_1 = require("protobufjs/minimal");
+const eth_pubkey_1 = require("./eth-pubkey");
 function toSafeAccountNumber(value) {
     return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
 }
+/**
+ * Like cosmjs's `decodeOptionalPubkey()`, but also understands the
+ * eth_secp256k1 pubkey the chain stores for eth accounts on first use
+ * (cosmjs throws "Pubkey type_url ... not recognized" for it). The wire
+ * format is the same as `cosmos.crypto.secp256k1.PubKey`.
+ */
+function decodeOptionalPubkeyWithEth(pubkeyAny) {
+    if (pubkeyAny && pubkeyAny.typeUrl === eth_pubkey_1.ETH_SECP256K1_PUBKEY_TYPE_URL) {
+        return (0, eth_pubkey_1.decodeEthSecp256k1Pubkey)(pubkeyAny.value);
+    }
+    return (0, proto_signing_1.decodeOptionalPubkey)(pubkeyAny);
+}
 function accountFromBaseAccount(input) {
     return {
         address: input.address,
-        pubkey: (0, proto_signing_1.decodeOptionalPubkey)(input.pubKey),
+        pubkey: decodeOptionalPubkeyWithEth(input.pubKey),
         accountNumber: toSafeAccountNumber(BigInt(input.accountNumber.toString())),
         sequence: Number(input.sequence),
     };
 }
+/**
+ * Extracts the nested `base_account` (field 1) out of a serialized EthAccount
+ * (`{ BaseAccount base_account = 1; string code_hash = 2; }`). There is no
+ * codegen for EthAccount in the client's proto packages (the chain's
+ * cosmos/evm version keeps eth accounts as plain BaseAccount), so the outer
+ * message is scanned manually as a defensive fallback for chains that do
+ * store EthAccount.
+ */
+function baseAccountFromEthAccount(value) {
+    const reader = minimal_1.Reader.create(value);
+    while (reader.pos < reader.len) {
+        const tag = reader.uint32();
+        // eslint-disable-next-line no-bitwise
+        if (tag >>> 3 === 1) {
+            return auth_1.BaseAccount.decode(reader.bytes());
+        }
+        // eslint-disable-next-line no-bitwise
+        reader.skipType(tag & 7);
+    }
+    throw new Error('EthAccount does not contain a base account');
+}
 /**
  * Bigint-safe replacement for cosmjs's `accountFromAny()`. Handles the account
- * types the chain actually uses (BaseAccount, ModuleAccount) itself and falls
- * back to the cosmjs parser for exotic ones (vesting etc.), which keeps the old
- * behavior for them.
+ * types the chain actually uses (BaseAccount, ModuleAccount — eth accounts are
+ * stored as BaseAccount with an eth_secp256k1 pubkey) plus the EthAccount
+ * wrappers other cosmos/evm chains use, and falls back to the cosmjs parser
+ * for exotic ones (vesting etc.), which keeps the old behavior for them.
  */
 function accountFromAny(input) {
     switch (input.typeUrl) {
@@ -31,8 +67,11 @@ function accountFromAny(input) {
             (0, utils_1.assert)(baseAccount);
             return accountFromBaseAccount(baseAccount);
         }
+        case '/cosmos.evm.types.v1.EthAccount':
+        case '/ethermint.types.v1.EthAccount':
+            return accountFromBaseAccount(baseAccountFromEthAccount(input.value));
         default:
             return (0, stargate_1.accountFromAny)(input);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY2xpZW50cy9saWIvYWNjb3VudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUE2Q0Esd0NBY0M7QUExREQseURBQTZEO0FBQzdELCtDQUEwRTtBQUMxRSx5Q0FBdUM7QUFDdkMsZ0VBQW1GO0FBc0JuRixTQUFTLG1CQUFtQixDQUFDLEtBQWE7SUFDeEMsT0FBTyxLQUFLLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztBQUMxRSxDQUFDO0FBRUQsU0FBUyxzQkFBc0IsQ0FBQyxLQUFrQjtJQUNoRCxPQUFPO1FBQ0wsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1FBQ3RCLE1BQU0sRUFBRSxJQUFBLG9DQUFvQixFQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7UUFDMUMsYUFBYSxFQUFFLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDMUUsUUFBUSxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDO0tBQ2pDLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxTQUFnQixjQUFjLENBQUMsS0FBVTtJQUN2QyxRQUFRLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUN0QixLQUFLLGtDQUFrQztZQUNyQyxPQUFPLHNCQUFzQixDQUFDLGtCQUFXLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBRWpFLEtBQUssb0NBQW9DLENBQUMsQ0FBQyxDQUFDO1lBQzFDLE1BQU0sV0FBVyxHQUFHLG9CQUFhLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxXQUFXLENBQUM7WUFDbEUsSUFBQSxjQUFNLEVBQUMsV0FBVyxDQUFDLENBQUM7WUFDcEIsT0FBTyxzQkFBc0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUM3QyxDQUFDO1FBRUQ7WUFDRSxPQUFPLElBQUEseUJBQW9CLEVBQUMsS0FBSyxDQUFDLENBQUM7SUFDdkMsQ0FBQztBQUNILENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/cjs/src/clients/lib/agent-approval-tx.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentApprovalDigest = void 0;
+exports.composeAgentApprovalMsg = composeAgentApprovalMsg;
+exports.signAgentApprovalTx = signAgentApprovalTx;
+const math_1 = require("@cosmjs/math");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+const eth_pubkey_1 = require("./eth-pubkey");
+const agent_approval_1 = require("./agent-approval");
+Object.defineProperty(exports, "agentApprovalDigest", { enumerable: true, get: function () { return agent_approval_1.agentApprovalDigest; } });
+const registry_1 = require("./registry");
+const eip712_signer_1 = require("../modules/eip712-signer");
+const constants_1 = require("../constants");
+/** Gas for registering one authenticator; well under the chain's ceiling. */
+const DEFAULT_APPROVAL_GAS = 200000;
+/**
+ * Builds MsgAddAuthenticator in its agent form: the chain reads the agent's
+ * address from `data` and builds the authenticator tree itself, which is what
+ * lets the approval be readable — no part of the granted authority travels in
+ * the transaction.
+ */
+function composeAgentApprovalMsg(options) {
+    return {
+        typeUrl: constants_1.TYPE_URL_MSG_ADD_AUTHENTICATOR,
+        value: {
+            sender: options.sender,
+            authenticatorType: agent_approval_1.AGENT_AUTHENTICATOR_TYPE,
+            data: (0, agent_approval_1.agentAddressBytes)(options.approval.agentAddress),
+            name: options.approval.agentName,
+            expiresAt: options.approval.expiresAt,
+        },
+    };
+}
+/**
+ * Signs an agent approval as a payload and returns the broadcastable TxRaw.
+ *
+ * The signer's public key is recovered from the very signature the wallet
+ * returns, so a wallet the app has never seen before can approve an agent
+ * without a separate prompt whose only purpose is to expose its key.
+ */
+async function signAgentApprovalTx(options, signTypedData, registry = (0, registry_1.generateRegistry)()) {
+    var _a;
+    const typedData = (0, agent_approval_1.agentApprovalTypedData)(options.approval);
+    const signatureHex = await signTypedData(typedData);
+    const signature = parseApprovalSignature(signatureHex);
+    const signerPubkey = (0, eip712_signer_1.recoverPubKeyFromTypedDataSignature)(typedData, signatureHex);
+    const msg = composeAgentApprovalMsg(options);
+    const bodyBytes = tx_1.TxBody.encode(tx_1.TxBody.fromPartial({
+        messages: [registry.encodeAsAny(msg)],
+        // Empty on purpose: the payload names none of these, so the ante refuses
+        // a transaction that carries them.
+        memo: '',
+    })).finish();
+    const authInfoBytes = (0, proto_signing_1.makeAuthInfoBytes)([
+        {
+            pubkey: (0, eth_pubkey_1.ethSecp256k1PubkeyToAny)((0, eth_pubkey_1.encodeEthSecp256k1Pubkey)(signerPubkey)),
+            // The approval's nonce IS the sequence, so the two cannot disagree.
+            sequence: options.approval.nonce,
+        },
+    ], 
+    // No fee: registering an agent is a fee-free operation, and a fee is
+    // something the signature does not cover.
+    [], math_1.Int53.fromString(String((_a = options.gas) !== null && _a !== void 0 ? _a : DEFAULT_APPROVAL_GAS)).toNumber(), undefined, undefined);
+    return Uint8Array.from(tx_1.TxRaw.encode(tx_1.TxRaw.fromPartial({
+        bodyBytes,
+        authInfoBytes,
+        signatures: [signature],
+    })).finish());
+}
+/** The wallet's 65-byte r ‖ s ‖ v, as the chain's recovery expects it. */
+function parseApprovalSignature(signatureHex) {
+    const hex = signatureHex.startsWith('0x') ? signatureHex.slice(2) : signatureHex;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i += 1) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    if (bytes.length !== 65) {
+        throw new Error(`Expected a 65-byte approval signature, got ${bytes.length} bytes`);
+    }
+    return bytes;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/cjs/src/clients/lib/agent-approval.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_AUTHENTICATOR_TYPE = exports.AGENT_REVOCATION_ADDRESS = exports.AGENT_APPROVAL_PRIMARY_TYPE = exports.AGENT_APPROVAL_DOMAIN_VERSION = exports.AGENT_APPROVAL_DOMAIN_NAME = void 0;
+exports.agentAddressToHex = agentAddressToHex;
+exports.agentApprovalTypedData = agentApprovalTypedData;
+exports.agentApprovalDigest = agentApprovalDigest;
+exports.agentAddressBytes = agentAddressBytes;
+const encoding_1 = require("@cosmjs/encoding");
+const ethers_1 = require("ethers");
+/**
+ * The approval a wallet is asked to sign when a trading key is authorized.
+ *
+ * Unlike a cosmos transaction — which EIP-712 renders as a machine-built "Tx"
+ * wrapping account_number, sequence, fee, gas and a nested msg0 — this payload
+ * is the approval itself: the agent, its name, when it expires, and a nonce.
+ * The chain rebuilds exactly this from MsgApproveAgent and checks the signature
+ * against it, so what the user read is what was authorized.
+ *
+ * Every name here is part of the digest and must match the chain byte for byte
+ * (protocol/x/accountplus/types/agent_eip712.go). The fixtures in
+ * __tests__/fixtures/agent_approval_goldens.json are generated by the chain and
+ * are what keeps the two in step.
+ */
+exports.AGENT_APPROVAL_DOMAIN_NAME = 'RubinSignTransaction';
+exports.AGENT_APPROVAL_DOMAIN_VERSION = '1';
+exports.AGENT_APPROVAL_PRIMARY_TYPE = 'RubinTransaction:ApproveAgent';
+/** verifyingContract is unused; the payload is not addressed to a contract. */
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * Renders a bech32 address as the 0x form the payload declares. Both are the
+ * same 20 bytes; a wallet can only display the hex one.
+ */
+function agentAddressToHex(address) {
+    if (address.startsWith('0x')) {
+        return address.toLowerCase();
+    }
+    return `0x${(0, encoding_1.toHex)((0, encoding_1.fromBech32)(address).data)}`;
+}
+/**
+ * The agent address that means "approve nobody": a revocation.
+ *
+ * Withdrawing a key rides the same payload as granting one — same domain, same
+ * fields, same signing path — because the moment a user most needs to read the
+ * dialog is the moment they are taking a key away. The chain removes the key
+ * whose name the payload carries (see IsAgentRevocation in agent.go).
+ */
+exports.AGENT_REVOCATION_ADDRESS = ZERO_ADDRESS;
+/** Builds the typed data the wallet signs. */
+function agentApprovalTypedData(approval) {
+    // The expiry is shown only when it says something. Zero means "give me the
+    // chain's default lifetime", and a wallet rendering `expiresAt: 0` reads as
+    // "never expires" — the opposite of the truth. So the zero case drops the
+    // field, which is a second SHAPE, not a hidden value: EIP-712 hashes the
+    // declared field list, so the two produce different digests and neither
+    // signature can be replayed as the other. The chain decides which shape
+    // applies from the message it executes (agent_eip712.go), never the signer.
+    const withExpiry = approval.expiresAt !== 0;
+    const fields = [
+        { name: 'rubinChain', type: 'string' },
+        { name: 'agentAddress', type: 'address' },
+        { name: 'agentName', type: 'string' },
+        ...(withExpiry ? [{ name: 'expiresAt', type: 'uint64' }] : []),
+        { name: 'nonce', type: 'uint64' },
+    ];
+    const message = {
+        rubinChain: approval.rubinChain,
+        agentAddress: agentAddressToHex(approval.agentAddress),
+        agentName: approval.agentName,
+        ...(withExpiry ? { expiresAt: approval.expiresAt } : {}),
+        nonce: approval.nonce,
+    };
+    return {
+        types: {
+            // No chainId: EIP-712 lets the domain carry any subset of its fields, and
+            // a wallet only compares chainId when it is present. Leaving it out means
+            // the approval does not depend on which network the wallet happens to be
+            // on, and the chain does not have to learn that from the transaction. The
+            // binding that matters is rubinChain below.
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            [exports.AGENT_APPROVAL_PRIMARY_TYPE]: fields,
+        },
+        primaryType: exports.AGENT_APPROVAL_PRIMARY_TYPE,
+        domain: {
+            name: exports.AGENT_APPROVAL_DOMAIN_NAME,
+            version: exports.AGENT_APPROVAL_DOMAIN_VERSION,
+            verifyingContract: ZERO_ADDRESS,
+        },
+        message,
+    };
+}
+/**
+ * The 32-byte digest the wallet signs: keccak(0x19 0x01 ‖ domainSeparator ‖
+ * hashStruct(message)).
+ */
+function agentApprovalDigest(approval) {
+    const typedData = agentApprovalTypedData(approval);
+    // ethers derives the primary type from the types map, so the EIP712Domain
+    // entry must not be part of what it is handed.
+    const { EIP712Domain: _domainType, ...messageTypes } = typedData.types;
+    return (0, ethers_1.getBytes)(ethers_1.TypedDataEncoder.hash(typedData.domain, messageTypes, typedData.message));
+}
+/**
+ * The authenticator type that marks the readable agent form of
+ * MsgAddAuthenticator: `data` is then the agent's 20-byte address and the chain
+ * builds the tree itself.
+ */
+exports.AGENT_AUTHENTICATOR_TYPE = 'Agent';
+/** The 20 address bytes the agent form carries as `data`. */
+function agentAddressBytes(address) {
+    if (address.startsWith('0x')) {
+        return (0, encoding_1.fromHex)(address.slice(2));
+    }
+    return (0, encoding_1.fromBech32)(address).data;
+}
+//# sourceMappingURL=data:application/json;base64,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