feat(PE-5758): add signer to ario class

examples/node/index.cjs

@@ -1,10 +1,14 @@
+const Arweave = require('arweave');
 const {
   ArIO,
   ARNS_TESTNET_REGISTRY_TX,
 } = require('../../lib/cjs/node/index.js');
+const { ArweaveSigner } = require('arbundles');
 
 (async () => {
-  const arIO = new ArIO();
+  const jwk = await Arweave.init({}).wallets.generate();
+  const signer = new ArweaveSigner(jwk);
+  const arIO = new ArIO({ signer });
   // testnet gateways
   const testnetGateways = await arIO.getGateways();
   const protocolBalance = await arIO.getBalance({

examples/node/index.mjs

@@ -1,7 +1,12 @@
+import { ArweaveSigner } from 'arbundles';
+import Arweave from 'arweave';
+
 import { ARNS_TESTNET_REGISTRY_TX, ArIO } from '../../lib/esm/node/index.js';
 
 (async () => {
-  const arIO = new ArIO();
+  const jwk = await Arweave.init({}).wallets.generate();
+  const signer = new ArweaveSigner(jwk);
+  const arIO = new ArIO({ signer });
   // testnet gateways
   const testnetGateways = await arIO.getGateways();
   const protocolBalance = await arIO.getBalance({

examples/web/index.html

@@ -131,10 +131,14 @@ <h1 class="text-textPrimary w-full font-bold">View Distribution Data</h1>
     </div>
 
     <script type="module">
+      import { ArconnectSigner } from 'https://unpkg.com/arbundles@0.11.0/build/web/esm/webIndex.js';
+      import Arweave from 'https://unpkg.com/arweave@1.14.4/web/index.js';
+
       import { ArIO } from './web.bundle.min.js';
 
-      // set up our client
-      const arIO = new ArIO();
+      const arweave = Arweave.init({});
+      const signer = new ArconnectSigner(window['arweaveWallet'], arweave);
+      const arIO = new ArIO({ signer });
 
       // fetch data on page load
       async function init() {

package.json

@@ -112,6 +112,7 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
+    "arbundles": "0.11.0",
     "arweave": "^1.14.4",
     "axios": "1.4.0",
     "setimmediate": "^1.0.5",

src/common.ts

@@ -14,6 +14,8 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+import { ArconnectSigner, ArweaveSigner } from 'arbundles';
+
 import {
   ANTRecord,
   ANTState,
@@ -32,17 +34,21 @@ export type SortKey = string;
 export type WalletAddress = string;
 
 // TODO: append this with other configuration options (e.g. local vs. remote evaluation)
-export type ContractConfiguration =
+export type ContractSigner = ArweaveSigner | ArconnectSigner;
+export type ContractConfiguration = {
+  signer?: ContractSigner; // TODO: optionally allow JWK in place of signer
+} & (
   | {
-      contract?: SmartWeaveContract<unknown>;
+      contract?: BaseContract<unknown> & ReadContract;
     }
   | {
       contractTxId: string;
-    };
+    }
+);
 
 export function isContractConfiguration<T>(
   config: ContractConfiguration,
-): config is { contract: SmartWeaveContract<T> } {
+): config is { contract: BaseContract<T> & ReadContract } {
   return 'contract' in config;
 }
 
@@ -62,19 +68,44 @@ export type EvaluationParameters<T = NonNullable<unknown>> = {
   evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
 } & T;
 
+export interface BaseContract<T> {
+  getState(params: EvaluationParameters): Promise<T>;
+  connect(signer: ContractSigner): this;
+}
+
+export interface ReadContract {
+  readInteraction<Input, State>({
+    functionName,
+    inputs,
+    evaluationOptions,
+  }: EvaluationParameters<{
+    functionName: string;
+    inputs?: Input;
+  }>): Promise<State>;
+}
+
+export interface WriteContract {
+  writeInteraction<Input, State>({
+    functionName,
+    inputs,
+    evaluationOptions,
+  }: EvaluationParameters<{
+    functionName: string;
+    inputs: Input;
+  }>): Promise<State>;
+}
+
 export interface SmartWeaveContract<T> {
   getContractState(params: EvaluationParameters): Promise<T>;
   readInteraction<I, K>({
     functionName,
     inputs,
     evaluationOptions,
   }: EvaluationParameters<{ functionName: string; inputs?: I }>): Promise<K>;
-  // TODO: write interaction
 }
 
 // TODO: extend with additional methods
-export interface ArIOContract {
-  getState({ evaluationOptions }: EvaluationParameters): Promise<ArIOState>;
+export interface ArIOContract extends BaseContract<ArIOState> {
   getGateway({
     address,
     evaluationOptions,
@@ -138,8 +169,7 @@ export interface ArIOContract {
   }>): Promise<ArNSAuctionData>;
 }
 
-export interface ANTContract {
-  getState({ evaluationOptions }: EvaluationParameters): Promise<ANTState>;
+export interface ANTContract extends BaseContract<ANTState> {
   getRecord({
     domain,
     evaluationOptions,

src/common/ant.ts

@@ -18,19 +18,23 @@ import {
   ANTContract,
   ANTRecord,
   ANTState,
+  BaseContract,
   ContractConfiguration,
+  ContractSigner,
   EvaluationOptions,
   EvaluationParameters,
-  SmartWeaveContract,
   isContractConfiguration,
   isContractTxIdConfiguration,
 } from '../types.js';
 import { RemoteContract } from './contracts/remote-contract.js';
+import { WarpContract } from './index.js';
 
-export class ANT implements ANTContract {
-  private contract: SmartWeaveContract<ANTState>;
+export class ANT implements ANTContract, BaseContract<ANTState> {
+  private contract: BaseContract<ANTState>;
+  private signer: ContractSigner | undefined;
 
-  constructor(config: ContractConfiguration) {
+  constructor({ signer, ...config }: ContractConfiguration) {
+    this.signer = signer;
     if (isContractConfiguration<ANTState>(config)) {
       this.contract = config.contract;
     } else if (isContractTxIdConfiguration(config)) {
@@ -40,13 +44,24 @@ export class ANT implements ANTContract {
     }
   }
 
+  connect(signer: ContractSigner): this {
+    this.signer = signer;
+    if (this.contract instanceof RemoteContract) {
+      const config = this.contract.configuration();
+      this.contract = new WarpContract<ANTState>({
+        ...config,
+        signer,
+      });
+    }
+    this.contract.connect(this.signer);
+
+    return this;
+  }
   /**
    * Returns the current state of the contract.
    */
-  async getState({
-    evaluationOptions,
-  }: EvaluationParameters = {}): Promise<ANTState> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  async getState(params: EvaluationParameters): Promise<ANTState> {
+    const state = await this.contract.getState(params);
     return state;
   }
 
@@ -62,53 +77,53 @@ export class ANT implements ANTContract {
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<Record<string, ANTRecord>> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<Record<string, ANTRecord>> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.records;
   }
 
   async getOwner({
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<string> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<string> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.owner;
   }
 
   async getControllers({
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<string[]> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<string[]> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.controllers;
   }
 
   async getName({
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<string> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<string> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.name;
   }
 
   async getTicker({
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<string> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<string> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.ticker;
   }
 
   async getBalances({
     evaluationOptions,
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
-  } = {}): Promise<Record<string, number>> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+  }): Promise<Record<string, number>> {
+    const state = await this.contract.getState({ evaluationOptions });
     return state.balances;
   }
 

src/common/ar-io.ts

@@ -20,41 +20,36 @@ import {
   ArIOState,
   ArNSAuctionData,
   ArNSNameData,
+  BaseContract,
   ContractConfiguration,
+  ContractSigner,
   EpochDistributionData,
   EvaluationOptions,
   EvaluationParameters,
   Gateway,
   Observations,
+  ReadContract,
   RegistrationType,
-  SmartWeaveContract,
   WeightedObserver,
+  isContractConfiguration,
+  isContractTxIdConfiguration,
 } from '../types.js';
 import { RemoteContract } from './contracts/remote-contract.js';
+import { WarpContract } from './index.js';
 
-function isContractConfiguration<T>(
-  config: ContractConfiguration,
-): config is { contract: SmartWeaveContract<T> } {
-  return 'contract' in config;
-}
-
-function isContractTxIdConfiguration(
-  config: ContractConfiguration,
-): config is { contractTxId: string } {
-  return 'contractTxId' in config;
-}
-
-export class ArIO implements ArIOContract {
-  private contract: SmartWeaveContract<ArIOState>;
+export class ArIO implements ArIOContract, BaseContract<ArIOState> {
+  private contract: BaseContract<ArIOState> & ReadContract;
+  private signer: ContractSigner | undefined;
 
   constructor(
-    config: ContractConfiguration = {
-      // default to a contract that uses the arns service to do the evaluation
+    { signer, ...config }: ContractConfiguration = {
       contract: new RemoteContract<ArIOState>({
         contractTxId: ARNS_TESTNET_REGISTRY_TX,
       }),
     },
   ) {
+    this.signer = signer;
+
     if (isContractConfiguration<ArIOState>(config)) {
       this.contract = config.contract;
     } else if (isContractTxIdConfiguration(config)) {
@@ -66,14 +61,26 @@ export class ArIO implements ArIOContract {
     }
   }
 
+  connect(signer: ContractSigner): this {
+    this.signer = signer;
+    if (this.contract instanceof RemoteContract) {
+      const config = this.contract.configuration();
+      this.contract = new WarpContract<ArIOState>({
+        ...config,
+        signer,
+      });
+    }
+    this.contract.connect(this.signer);
+
+    return this;
+  }
   /**
    * Returns the current state of the contract.
    */
   async getState(params: EvaluationParameters): Promise<ArIOState> {
-    const state = await this.contract.getContractState(params);
+    const state = await this.contract.getState(params);
     return state;
   }
-
   /**
    * Returns the ARNS record for the given domain.
    */
@@ -93,7 +100,7 @@ export class ArIO implements ArIOContract {
   async getArNSRecords({
     evaluationOptions,
   }: EvaluationParameters = {}): Promise<Record<string, ArNSNameData>> {
-    const state = await this.contract.getContractState({ evaluationOptions });
+    const state = await this.contract.getState({ evaluationOptions });
     return state.records;
   }
 
@@ -114,7 +121,7 @@ export class ArIO implements ArIOContract {
   async getBalances({ evaluationOptions }: EvaluationParameters = {}): Promise<
     Record<string, number>
   > {
-    const state = await this.contract.getContractState({ evaluationOptions });
+    const state = await this.contract.getState({ evaluationOptions });
     return state.balances;
   }
 
@@ -199,15 +206,15 @@ export class ArIO implements ArIOContract {
   }: EvaluationParameters<{
     epochStartHeight?: number;
   }> = {}): Promise<Observations> {
-    const { observations } = await this.contract.getContractState({
+    const { observations } = await this.contract.getState({
       evaluationOptions,
     });
     return observations;
   }
   async getDistributions({
     evaluationOptions,
   }: EvaluationParameters = {}): Promise<EpochDistributionData> {
-    const { distributions } = await this.contract.getContractState({
+    const { distributions } = await this.contract.getState({
       evaluationOptions,
     });
     return distributions;
@@ -235,7 +242,7 @@ export class ArIO implements ArIOContract {
   }: {
     evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
   }): Promise<Record<string, ArNSAuctionData>> {
-    const { auctions } = await this.contract.getContractState({
+    const { auctions } = await this.contract.getState({
       evaluationOptions,
     });